@dxos/compute 0.9.1-staging.ee54ba693a → 0.11.0

package/dist/lib/index.mjs

@@ -0,0 +1,1576 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { C as RunAgainError, S as NoHandlerError, T as TriggerStateNotFoundError, _ as FunctionsAiMemoizationMissError, b as InvalidOperationOutputError, c as PersistentOperation, d as invoke, f as isIdempotent, g as FunctionNotFoundError, h as FunctionError, i as getHandlerByKey, n as OperationHandlerSet_exports, o as NotifyOptions, r as getHandler, s as Operation_exports, t as OperationHandlerProvider, u as deserialize, v as FunctionsAiUpstreamError, w as ServiceNotAvailableError, x as InvokerNotInitializedError, y as InvalidOperationInputError } from "./chunk-OperationHandlerSet.mjs";
+import { t as AgentService_exports } from "./AgentService.mjs";
+import { cell, t as StorageService_exports, withDefault } from "./StorageService.mjs";
+import { BaseError } from "@dxos/errors";
+import * as Schema from "effect/Schema";
+import { Annotation, Collection, DXN, Database, Feed, Filter, Format, JsonSchema, Obj, Query, QueryAST, Ref, Registry, Type, URI } from "@dxos/echo";
+import { Text } from "@dxos/schema";
+import * as Effect from "effect/Effect";
+import { ToolId } from "@dxos/ai";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import Handlebars from "@dxos/vendor-kbn-handlebars";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as SchemaAST from "effect/SchemaAST";
+import { FormInlineAnnotation, FormInputAnnotation, HiddenAnnotation, LabelAnnotation } from "@dxos/echo/Annotation";
+import { OptionsAnnotationId } from "@dxos/echo/Format";
+import { Outline, TaskSet } from "@dxos/types";
+import { LabelAnnotation as LabelAnnotation$1 } from "@dxos/echo/internal";
+import * as Redacted from "effect/Redacted";
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import { BYOK_HEADER } from "@dxos/protocols";
+import { DXN as DXN$1, EID, URI as URI$1 } from "@dxos/keys";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import * as Either from "effect/Either";
+//#region src/McpServer.ts
+var McpServer_exports = /* @__PURE__ */ __exportAll({ McpServer: () => McpServer });
+/**
+* MCP server connection spec — the minimal fields needed to dial an MCP server.
+*
+* Used as a value type embedded in skills and passed to runtime session connect logic.
+* The user-facing ECHO object (`@dxos/assistant-toolkit` `McpServer`) composes this struct
+* and adds instance-level fields (`name`, `enabled`) and ECHO annotations.
+*/
+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" })
+});
+//#endregion
+//#region src/types/Template.ts
+var Template_exports = /* @__PURE__ */ __exportAll({
+	Input: () => Input,
+	InputKind: () => InputKind,
+	Template: () => Template,
+	make: () => make$9,
+	process: () => process,
+	processTemplate: () => processTemplate
+});
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/compute/compute/src/types/Template.ts";
+/**
+* Template input kind determines how template variables are resolved.
+*/
+var InputKind = Schema.Literal("value", "operation");
+/**
+* Template input variable.
+* E.g., {{foo}}
+*/
+var Input = Schema.Struct({
+	name: Schema.String,
+	kind: InputKind,
+	default: Schema.optional(Schema.Any),
+	/**
+	* Operation key invoked when `kind === 'operation'`. The referenced operation must accept void input —
+	* template inputs have no mechanism for passing arguments.
+	*/
+	operation: Schema.optional(Schema.String)
+});
+/**
+* Template type.
+*/
+var Template = Schema.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: Schema.optional(Schema.Array(Input))
+});
+var make$9 = ({ id, source, inputs = [] } = {}) => ({
+	source: Ref.make(Text.make({
+		id,
+		content: source
+	})),
+	inputs
+});
+/**
+* Process Handlebars template.
+*/
+var process = (source, variables = {}) => {
+	assertArgument(typeof source === "string", "source");
+	let section = 0;
+	const handlebars = Handlebars.create();
+	handlebars.registerHelper("section", () => String(++section));
+	return handlebars.compileAST(source.trim())(variables).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$2,
+					L: 99,
+					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 result = yield* invoke(deserialize(results[0]), 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$2,
+		L: 124,
+		S: this
+	});
+	return process((yield* Database.load(template.source)).content, variables);
+});
+//#endregion
+//#region src/Runnable.ts
+var Runnable_exports = /* @__PURE__ */ __exportAll({ Runnable: () => Runnable });
+var Runnable = PersistentOperation;
+//#endregion
+//#region src/types/Trigger.ts
+var Trigger_exports = /* @__PURE__ */ __exportAll({
+	DirectSpec: () => DirectSpec,
+	EmailSpec: () => EmailSpec,
+	FeedSpec: () => FeedSpec,
+	InputTemplate: () => InputTemplate,
+	Kinds: () => Kinds$1,
+	Spec: () => Spec,
+	SubscriptionSpec: () => SubscriptionSpec,
+	TimerSpec: () => TimerSpec,
+	Trigger: () => Trigger,
+	TriggerMonitorService: () => TriggerMonitorService,
+	WebhookSpec: () => WebhookSpec,
+	isManuallyInvokable: () => isManuallyInvokable,
+	make: () => make$8,
+	specDirect: () => specDirect,
+	specEmail: () => specEmail,
+	specFeed: () => specFeed,
+	specSubscription: () => specSubscription,
+	specTimer: () => specTimer,
+	specWebhook: () => specWebhook
+});
+/**
+* Type discriminator for TriggerType.
+* Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
+* https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
+*/
+var Kinds$1 = [
+	"email",
+	"feed",
+	"direct",
+	"subscription",
+	"timer",
+	"webhook"
+];
+var kindLiteralAnnotations = { title: "Kind" };
+var EmailSpec = Schema.Struct({ kind: Schema.Literal("email").annotations(kindLiteralAnnotations) });
+/**
+* Construct an Email trigger spec.
+*/
+var specEmail = () => ({ kind: "email" });
+var FeedSpec = Schema.Struct({
+	kind: Schema.Literal("feed").annotations(kindLiteralAnnotations),
+	feed: Schema.optional(Ref.Ref(Feed.Feed).annotations({ title: "Feed" }))
+});
+/**
+* Construct a Feed trigger spec from a Feed object.
+*/
+var specFeed = (feed) => ({
+	kind: "feed",
+	feed: Ref.make(feed)
+});
+/**
+* Subscription.
+*/
+var SubscriptionSpec = Schema.Struct({
+	kind: Schema.Literal("subscription").annotations(kindLiteralAnnotations),
+	query: Schema.Struct({
+		raw: Schema.optional(Schema.String.annotations({ title: "Query" })),
+		ast: QueryAST.Query
+	}),
+	options: Schema.optional(Schema.Struct({
+		deep: Schema.optional(Schema.Boolean.annotations({ title: "Nested" })),
+		delay: Schema.optional(Schema.Number.annotations({ title: "Delay" }))
+	}).annotations({ title: "Options" }))
+});
+/**
+* Construct a Subscription trigger spec from a Query object.
+*/
+var specSubscription = (query, options) => ({
+	kind: "subscription",
+	query: { ast: query.ast },
+	options: options ? {
+		deep: options.deep,
+		delay: options.delay
+	} : void 0
+});
+/**
+* Direct invocation only; never scheduled by the dispatcher (invoked on demand by a caller).
+*/
+var DirectSpec = Schema.Struct({ kind: Schema.Literal("direct").annotations(kindLiteralAnnotations) });
+/**
+* Construct a Direct trigger spec.
+*/
+var specDirect = () => ({ kind: "direct" });
+/**
+* Cron timer.
+*/
+var TimerSpec = Schema.Struct({
+	kind: Schema.Literal("timer").annotations(kindLiteralAnnotations),
+	cron: Schema.String.annotations({
+		title: "Cron",
+		[SchemaAST.ExamplesAnnotationId]: ["0 0 * * *"]
+	})
+});
+/**
+* Construct a Timer trigger spec from a cron string.
+*/
+var specTimer = (cron) => ({
+	kind: "timer",
+	cron
+});
+/**
+* Webhook.
+*/
+var WebhookSpec = Schema.Struct({
+	kind: Schema.Literal("webhook").annotations(kindLiteralAnnotations),
+	method: Schema.optional(Schema.String.annotations({
+		title: "Method",
+		[OptionsAnnotationId]: ["GET", "POST"]
+	})),
+	port: Schema.optional(Schema.Number.annotations({ title: "Port" }))
+});
+/**
+* Construct a Webhook trigger spec from a method and port.
+*/
+var specWebhook = (opts) => ({
+	kind: "webhook",
+	method: opts?.method,
+	port: opts?.port
+});
+/**
+* Trigger schema.
+*/
+var Spec = Schema.Union(EmailSpec, FeedSpec, DirectSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({ title: "Trigger" });
+/**
+* Forms the input data passed to the function.
+* Must match the function's input schema.
+*
+* @example
+* {
+*   item: '{{event.item}}',
+*   instructions: 'Summarize and perform entity-extraction'
+*   mailbox: { '/': 'echo://AAA/ZZZ' }
+* }
+*/
+var InputTemplate = Schema.Record({
+	key: Schema.String,
+	value: Schema.Any
+});
+/**
+* Function trigger.
+* Runnable is invoked with the `payload` passed as input data.
+* The event that fires the trigger is available in the runnable context.
+*/
+var Trigger = class extends Type.makeObject(DXN.make("org.dxos.type.trigger", "0.1.0"))(Schema.Struct({
+	/**
+	* Runnable (operation or workflow) to invoke.
+	* Wired programmatically (see plugin-routine's `wireTriggers`); not user-editable, so hidden from forms.
+	*/
+	runnable: Ref.Ref(Runnable).pipe(Schema.annotations({ title: "Runnable" }), Annotation.FormInputAnnotation.set(false), Schema.optional),
+	spec: Spec.pipe(Schema.optional),
+	enabled: Schema.Boolean.pipe(Schema.optional),
+	/**
+	* Runs this trigger on the edge rather than locally.
+	* When unset, the trigger runs locally on the client.
+	*/
+	remote: Schema.Boolean.pipe(Schema.annotations({ title: "Remote" }), Schema.optional),
+	concurrency: Schema.Number.pipe(Schema.annotations({
+		title: "Concurrency",
+		default: 1,
+		description: "Maximum number of concurrent invocations of the trigger."
+	}), Annotation.FormInputAnnotation.set(false), Schema.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: Schema.String.pipe(Schema.annotations({ title: "Input Node ID" }), Annotation.FormInputAnnotation.set(false), Schema.optional),
+	/**
+	* Passed as the input data to the runnable.
+	*/
+	input: InputTemplate.pipe(Annotation.FormInputAnnotation.set(false), Schema.optional)
+}).pipe(Annotation.IconAnnotation.set({
+	icon: "ph--lightning--regular",
+	hue: "yellow"
+}), HiddenAnnotation.set(true))) {};
+var make$8 = (props) => Obj.make(Trigger, props);
+/**
+* Checks if a trigger having this spec can be manually invoked (a `direct` or `timer` trigger).
+*/
+var isManuallyInvokable = (spec) => spec?.kind === "direct" || spec?.kind === "timer";
+/**
+* Service for monitoring trigger executions.
+*/
+var TriggerMonitorService = class extends Context.Tag("@dxos/functions/TriggerMonitorService")() {};
+//#endregion
+//#region src/types/Skill.ts
+var Skill_exports = /* @__PURE__ */ __exportAll({
+	Hook: () => Hook,
+	HookSpec: () => HookSpec,
+	NotFoundError: () => NotFoundError,
+	Skill: () => Skill,
+	getKey: () => getKey,
+	getVersion: () => getVersion,
+	make: () => make$7,
+	registryURI: () => registryURI,
+	resolve: () => resolve$2,
+	toolDefinitions: () => toolDefinitions,
+	upsert: () => upsert
+});
+/**
+* Skill schema defines the structure for AI assistant skills.
+* Skills contain instructions, tools, and artifacts that guide the AI's behavior.
+* Skills may use tools to create and read artifacts, which are managed by the assistant.
+*
+* The registry `key` and `version` are stored in the object meta — access them via
+* `Obj.getMeta(skill).key` and `Obj.getMeta(skill).version`.
+*/
+var Skill = class extends Type.makeObject(DXN.make("org.dxos.type.skill", "0.2.0"))(Schema.Struct({
+	/**
+	* Human-readable name of the skill.
+	*/
+	name: Schema.String.annotations({ description: "Human-readable name of the skill" }),
+	/**
+	* Description of the skill's purpose and functionality.
+	*/
+	description: Schema.optional(Schema.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: Schema.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: Schema.optional(Schema.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: Schema.optional(Schema.Array(McpServer)),
+	/**
+	* Hooks triggered automatically at certain points in the agent's lifecycle.
+	*/
+	hooks: Schema.optional(Schema.Array(Schema.suspend(() => Hook)))
+}).pipe(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--blueprint--regular",
+	hue: "sky"
+}))) {};
+/**
+* Controls when the hook is triggered.
+*/
+var HookSpec = Schema.Union(
+	/**
+	* Triggered when the agent is about to start a request.
+	* A request is a series of agent/tool turns that the model drives.
+	*/
+	Schema.TaggedStruct("begin-request", {}),
+	/**
+	* Triggered when the agent has completed a request.
+	* A request is a series of agent/tool turns that the model drives.
+	*/
+	Schema.TaggedStruct("end-request", {})
+);
+/**
+* Allows hooking into the agent's lifecycle.
+* NOTE: Intentionally similar to Trigger, perhaps we should merge them.
+*/
+var Hook = Schema.Struct({
+	/**
+	* What to do when the hook is triggered.
+	*
+	* Can be a Ref to a PersistentOperation.
+	*/
+	function: Schema.optional(Ref.Ref(Obj.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(Annotation.FormInputAnnotation.set(false), Schema.optional)
+});
+/**
+* Create a new Skill.
+* The `key` (and optional `version`) are stored in the object meta.
+* `key` must be a valid DXN name (e.g. `org.dxos.skill.mySkill`).
+*/
+var make$7 = ({ key, version, tools = [], instructions = make$9(), ...props }) => Obj.make(Skill, {
+	[Obj.Meta]: {
+		key,
+		version
+	},
+	tools,
+	instructions,
+	...props
+});
+/**
+* Get the registry key for a skill.
+*/
+var getKey = (skill) => {
+	const key = Obj.getMeta(skill).key;
+	if (key === void 0) throw new Error("Skill is missing the meta key.");
+	return key;
+};
+/**
+* Get the registry version for a skill, if any.
+*/
+var getVersion = (skill) => Obj.getMeta(skill).version;
+/**
+* Util to create tool definitions for a skill.
+*/
+var toolDefinitions = ({ tools = [], operations = [] }) => [...operations.map((op) => ToolId.make(DXN.getName(op.meta.key))), ...tools.map((tool) => ToolId.make(tool))];
+/**
+* Returns the canonical URI used to reference this skill in the registry.
+* Use this URI with `Ref.fromURI` to bind a skill without cloning it to the DB.
+*
+* TODO(wittjosiah): Should use Obj.getURI instead once it supports options to prefer meta key over EID.
+*/
+var registryURI = (key) => DXN.tryMake(`dxn:${key}`) ?? URI.make(key);
+/**
+* Resolves a skill from the registry by its meta key.
+* Does not check the local database for the skill.
+*/
+var resolve$2 = (key) => Effect.gen(function* () {
+	const skill = (yield* Registry.runQuery(Filter.and(Filter.type(Skill), Filter.key(key))))[0];
+	if (!skill) return yield* Effect.fail(new NotFoundError({ context: { key } }));
+	return skill;
+});
+/**
+* Upserts a skill into the database.
+* If the skill already exists in the database, the local (possibly forked) copy is returned as-is.
+* Otherwise, a fresh copy is cloned from the registry and added.
+* @deprecated Since we're using a registry we no longer need to store skills in the database.
+*/
+var upsert = (key) => Effect.gen(function* () {
+	const local = yield* Database.query(Filter.and(Filter.type(Skill), Filter.key(key))).run;
+	if (local.length > 0) return local[0];
+	return yield* Database.add(Obj.clone(yield* resolve$2(key), { deep: "all" }));
+});
+var NotFoundError = class extends BaseError.extend("SkillNotFound", "Skill not found") {};
+//#endregion
+//#region src/types/Instructions.ts
+var Instructions_exports = /* @__PURE__ */ __exportAll({
+	Command: () => Command,
+	Instructions: () => Instructions,
+	make: () => make$6
+});
+/** A sentinel command the model recognizes in chat (e.g. `$track <text>`). */
+var Command = Schema.Struct({
+	sentinel: Schema.String.annotations({ description: "Token that invokes the command (e.g. \"$track\")." }),
+	description: Schema.optional(Schema.String),
+	prompt: Schema.String.annotations({ description: "What the model should do when the sentinel appears." })
+});
+/**
+* Prompt-based operation.
+* May reference skills and additional context.
+* Hidden from the navtree and object picker — accessed only through Routines.
+*/
+var Instructions = class extends Type.makeObject(DXN.make("org.dxos.type.instructions", "0.1.0"))(Schema.Struct({
+	name: Schema.optional(Schema.String),
+	description: Schema.optional(Schema.String),
+	input: JsonSchema.JsonSchema.pipe(Annotation.FormInputAnnotation.set(false)).annotations({ description: "Input schema" }),
+	output: JsonSchema.JsonSchema.pipe(Annotation.FormInputAnnotation.set(false)).annotations({ description: "Output schema" }),
+	text: Ref.Ref(Text.Text).pipe(Format.FormatAnnotation.set(Format.TypeFormat.Markdown), Schema.annotations({
+		title: "Instructions",
+		description: "Describe what the agent should do in each session."
+	})),
+	skills: Schema.Array(Ref.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: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(Schema.annotations({ title: "Objects" }), Schema.optional),
+	/** Sentinel commands available to chat sessions running with these instructions. */
+	commands: Schema.Array(Command).pipe(Schema.annotations({ title: "Commands" }), Schema.optional)
+}).pipe(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--scroll--regular",
+	hue: "sky"
+}), Annotation.HiddenAnnotation.set(true))) {};
+/** Creates an Instructions object with an owned Markdown `text` body (parented so it cascades and deep-clones). */
+var make$6 = ({ name, description, input, output, text, skills = [], objects, commands }) => {
+	const body = Text.make({ content: text ?? "" });
+	const instructions = Obj.make(Instructions, {
+		name,
+		description,
+		input: JsonSchema.toJsonSchema(input ?? Schema.Void),
+		output: JsonSchema.toJsonSchema(output ?? Schema.Void),
+		text: Ref.make(body),
+		skills,
+		objects,
+		commands
+	});
+	Obj.setParent(body, instructions);
+	return instructions;
+};
+//#endregion
+//#region src/types/Routine.ts
+var Routine_exports = /* @__PURE__ */ __exportAll({
+	Kind: () => Kind,
+	Routine: () => Routine,
+	instanceOf: () => instanceOf,
+	instructionsRef: () => instructionsRef,
+	make: () => make$5,
+	runnableRef: () => runnableRef
+});
+var Kind = Schema.Literal(...["runnable", "instructions"]);
+var RunnableSpec = Schema.Struct({
+	kind: Schema.Literal("runnable"),
+	runnable: Ref.Ref(Runnable)
+});
+var InstructionsSpec = Schema.Struct({
+	kind: Schema.Literal("instructions"),
+	instructions: Ref.Ref(Instructions)
+});
+var RoutineSpec = Schema.Union(RunnableSpec, InstructionsSpec);
+/**
+* User-facing routine: a thin aggregate of an action (`runnable`) and the triggers that fire it.
+* App-level only — EDGE stays unaware of it (triggers point directly at the runnable).
+*/
+var Routine = class extends Type.makeObject(DXN.make("org.dxos.type.routine", "0.2.0"))(Schema.Struct({
+	name: Schema.String.pipe(Schema.optional),
+	description: Schema.String.pipe(Schema.optional),
+	/**
+	* The action to run: either an Operation (`spec.runnable`, bound directly) or the routine's own owned
+	* Instructions (`spec.instructions`). For an Operation action the trigger's `runnable` points at this
+	* Operation. For an Instructions action `spec.instructions` is the owned Instructions object (the operation
+	* is implicitly the static RunInstructions, so no separate operation ref is stored), and the trigger's
+	* `runnable` is RunInstructions with this instructions bound as its input.
+	*/
+	spec: RoutineSpec.pipe(Schema.optional),
+	/**
+	* Explicit membership, bi-directional with `trigger.runnable → runnable`. Required (not derived by query)
+	* because the runnable may be a shared registry operation referenced by multiple automations, which would
+	* conflate triggers. MVP enforces length <= 1.
+	*/
+	triggers: Schema.Array(Ref.Ref(Trigger))
+}).pipe(LabelAnnotation$1.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--lightning--regular",
+	hue: "amber"
+}))) {};
+/** Returns true when value is a Routine object. */
+var instanceOf = (value) => Obj.instanceOf(Routine, value);
+/**
+* The owned Instructions ref of an instructions-action routine, or undefined for an operation action.
+* Classification is explicit in `spec.kind`, so this needs no `.target` dereference; callers resolve the ref
+* reactively (`useObject`) or asynchronously (`Database.load`) as appropriate.
+*/
+var instructionsRef = (routine) => routine.spec?.kind === "instructions" ? routine.spec.instructions : void 0;
+/** The Operation (runnable) ref of an operation-action routine, or undefined for an instructions action. */
+var runnableRef = (routine) => routine.spec?.kind === "runnable" ? routine.spec.runnable : void 0;
+/** Factory wrapper around `Obj.make` for {@link Routine}. Trigger wiring lives in plugin-routine (`makeRoutine`). */
+var make$5 = (props) => Obj.make(Routine, {
+	...props,
+	triggers: props.triggers ?? []
+});
+//#endregion
+//#region src/types/Project.ts
+var Project_exports = /* @__PURE__ */ __exportAll({
+	Goal: () => Goal,
+	Project: () => Project,
+	contextBindings: () => contextBindings,
+	make: () => make$4
+});
+/** Lightweight inline goal: per-item status and addressability without document ceremony. */
+var Goal = Schema.Struct({
+	id: Schema.String,
+	text: Schema.String,
+	status: Schema.optional(Schema.Literal("open", "met", "dropped"))
+});
+/**
+* A user-facing container for interactive, long-running work: instructions (skills + commands),
+* routines, artifacts, and AI chat sessions in project context. Successor to `Topic`.
+* Chats and agents attach via relations/queries (assistant-toolkit depends on compute, so no typed refs here).
+*/
+var Project = class extends Type.makeObject(DXN.make("org.dxos.type.project", "0.3.0"))(Schema.Struct({
+	name: Schema.optional(Schema.String),
+	description: Schema.optional(Schema.String),
+	/** Owned agent instructions (created + parented at the plugin layer). */
+	instructions: Schema.optional(Ref.Ref(Instructions).pipe(FormInlineAnnotation.set(true))),
+	/** Routines created within the scope of this project. */
+	routines: Schema.Array(Ref.Ref(Routine)),
+	/** Owned collection of artifacts (documents, outliners, tables, ...) managed by the project. */
+	artifacts: Schema.optional(Ref.Ref(Collection.Collection)),
+	/** What done means for this project. */
+	goals: Schema.optional(Schema.Array(Goal)),
+	/** Ad hoc markdown checklist — the scratch surface; project chats write into it. */
+	outline: Schema.optional(Ref.Ref(Outline.Outline)),
+	/** Owned (or adopted synced) task container; membership is the ECHO parent edge. */
+	taskSet: Schema.optional(Ref.Ref(TaskSet.TaskSet))
+}).pipe(Schema.annotations({ title: "Project" }), LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--stack--regular",
+	hue: "amber"
+}))) {};
+/** Factory wrapper around `Obj.make` for {@link Project}. */
+var make$4 = (props = {}) => Obj.make(Project, {
+	...props,
+	routines: props.routines ?? []
+});
+/**
+* Bindings a chat session should receive when running in this project's context: the instructions'
+* skills and context objects. The instructions object itself is NOT bound — its text/commands reach
+* the system prompt through the chat's `instructions` ref, and a bound Instructions object would
+* render as an inert context stub. Requires the instructions ref to be resolved (`.target`);
+* unresolved refs contribute nothing.
+*/
+var contextBindings = (project) => {
+	const instructionsRef = project.instructions;
+	if (!instructionsRef?.isAvailable) return {
+		skills: [],
+		objects: []
+	};
+	const instructions = instructionsRef.target;
+	if (!instructions) return {
+		skills: [],
+		objects: []
+	};
+	return {
+		skills: [...instructions.skills],
+		objects: [...instructions.objects ?? []]
+	};
+};
+//#endregion
+//#region src/types/Script.ts
+var Script_exports = /* @__PURE__ */ __exportAll({
+	Script: () => Script,
+	make: () => make$3
+});
+/**
+* Source script.
+*/
+var Script = class extends Type.makeObject(DXN.make("org.dxos.type.script", "0.1.0"))(Schema.Struct({
+	name: Schema.String.pipe(Schema.optional),
+	description: Schema.String.pipe(Schema.optional),
+	changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
+	source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--code--regular",
+	hue: "sky"
+}))) {};
+var make$3 = ({ source = "", ...props } = {}) => Obj.make(Script, {
+	...props,
+	source: Ref.make(Text.make({ content: source }))
+});
+//#endregion
+//#region src/types/TriggerEvent.ts
+var TriggerEvent_exports = /* @__PURE__ */ __exportAll({
+	DirectEvent: () => DirectEvent,
+	EmailEvent: () => EmailEvent,
+	FeedEvent: () => FeedEvent,
+	SubscriptionEvent: () => SubscriptionEvent,
+	SubscriptionMutationType: () => SubscriptionMutationType,
+	TimerEvent: () => TimerEvent,
+	TriggerEvent: () => TriggerEvent,
+	WebhookEvent: () => WebhookEvent
+});
+var EmailEvent = Schema.Struct({
+	from: Schema.String,
+	to: Schema.String,
+	subject: Schema.String,
+	created: Schema.String,
+	body: Schema.String
+});
+var FeedEvent = Schema.Struct({
+	feed: Ref.Ref(Feed.Feed),
+	item: Schema.Any,
+	cursor: Schema.String
+});
+/**
+* Kind of mutation a subscription trigger observed for its subject.
+*/
+var SubscriptionMutationType = Schema.Literal("created", "updated", "deleted");
+var SubscriptionEvent = Schema.Struct({
+	/**
+	* Type of the mutation.
+	*/
+	type: SubscriptionMutationType,
+	/**
+	* Reference to the object that was changed or created. For `deleted`, carries the object's URI;
+	* dereferencing may yield `undefined` since the object is gone.
+	*/
+	subject: Ref.Ref(Obj.Unknown),
+	/**
+	* @deprecated Use `subject`.
+	*/
+	changedObjectId: Schema.optional(Schema.String)
+});
+var TimerEvent = Schema.Struct({ tick: Schema.Number });
+var DirectEvent = Schema.Struct({ data: Schema.optional(Schema.Record({
+	key: Schema.String,
+	value: Schema.Any
+})) });
+var WebhookEvent = Schema.Struct({
+	url: Schema.String,
+	method: Schema.Literal("GET", "POST"),
+	headers: Schema.Record({
+		key: Schema.String,
+		value: Schema.String
+	}),
+	bodyText: Schema.String
+});
+var TriggerEvent = Schema.Union(EmailEvent, FeedEvent, DirectEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+//#endregion
+//#region src/AgentIdentity.ts
+var AgentIdentity_exports = /* @__PURE__ */ __exportAll({
+	AgentIdentity: () => AgentIdentity,
+	currentDid: () => currentDid
+});
+var AgentIdentity = class extends Context.Tag("@dxos/compute/AgentIdentity")() {};
+/**
+* The current author DID, or `undefined` when no {@link AgentIdentity} is in scope (e.g. a human-
+* initiated invocation). Reads optionally, so an operation that defaults its author from the agent
+* identity does not add a hard service requirement.
+*/
+var currentDid = Effect.serviceOption(AgentIdentity).pipe(Effect.map(Option.match({
+	onNone: () => void 0,
+	onSome: (identity) => identity.did
+})));
+//#endregion
+//#region src/Cancellation.ts
+var Cancellation_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service$1,
+	signal: () => signal
+});
+/**
+* Cooperative cancellation of the current operation run. The runtime that owns execution provides
+* the service and fires the signal when the run is cancelled — the EDGE worker on a client cancel
+* request, the local process runtime on terminate. Operations observe it via {@link signal}.
+*/
+var Service$1 = class extends Context.Tag("@dxos/compute/Cancellation")() {};
+/**
+* The current run's cancellation signal — e.g. for `Pipeline.abortWith` or `fetch`. Never fires when
+* the runtime provided no cancellation channel.
+*/
+var signal = Effect.serviceOption(Service$1).pipe(Effect.map(Option.match({
+	onNone: () => new AbortController().signal,
+	onSome: (service) => service.signal
+})));
+//#endregion
+//#region src/Credential.ts
+var Credential_exports = /* @__PURE__ */ __exportAll({
+	AccessTokenResolver: () => AccessTokenResolver,
+	CredentialsService: () => CredentialsService,
+	getApiKeyValue: () => getApiKeyValue
+});
+/**
+* Source for credentials EDGE custodies rather than replicating into the space (those stored as
+* `MANAGED_ACCESS_TOKEN`).
+*
+* An implementation detail of {@link CredentialsService}, not a consumer-facing service: it exists
+* as a tag only because the two surfaces reach EDGE differently — clients over authenticated HTTP,
+* functions over a space-bound service binding. Implementations cache; pass `refresh` to bypass that
+* cache after an authorization failure.
+*/
+var AccessTokenResolver = class AccessTokenResolver extends Context.Tag("@dxos/functions/AccessTokenResolver")() {
+	static resolve = (request) => Effect.gen(function* () {
+		const resolver = yield* AccessTokenResolver;
+		return yield* Effect.promise(() => resolver.resolve(request));
+	});
+	/**
+	* Fails on every managed token. The default where EDGE is unreachable (tests, offline CLI runs):
+	* a managed credential genuinely cannot be resolved there, and failing says so.
+	*/
+	static notAvailable = Layer.succeed(AccessTokenResolver, { resolve: async ({ accessTokenId }) => {
+		throw new Error(`No access token resolver configured; cannot resolve managed token: ${accessTokenId}`);
+	} });
+};
+var CredentialsService = class CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
+	static getCredential = (query) => Effect.gen(function* () {
+		const credentials = yield* CredentialsService;
+		return yield* Effect.promise(() => credentials.getCredential(query));
+	});
+	static getApiKey = (query) => Effect.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);
+	});
+};
+/**
+* The credential's API key as a plain string — what a caller passing it to an HTTP client needs.
+* Resolves a server-custodied value transparently, so callers never branch on where it came from.
+*/
+var getApiKeyValue = (query) => Effect.map(CredentialsService.getApiKey(query), Redacted.value);
+//#endregion
+//#region src/Header.ts
+var Header_exports = /* @__PURE__ */ __exportAll({ byokLayer: () => byokLayer });
+/**
+* Wraps an `HttpClient` so outbound requests carry `X-BYOK: <apiKey>` whenever the active space
+* has an `AccessToken` for `providerHost`. Lookup failures pass the request through unchanged.
+*/
+var byokLayer = (providerHost) => Layer.effect(HttpClient.HttpClient, Effect.gen(function* () {
+	const client = yield* HttpClient.HttpClient;
+	const credentials = yield* CredentialsService;
+	return HttpClient.mapRequestEffect(client, (request) => Effect.gen(function* () {
+		const apiKey = (yield* Effect.tryPromise(() => credentials.queryCredentials({ service: providerHost })).pipe(Effect.orElseSucceed(() => []))).find((credential) => credential.apiKey)?.apiKey;
+		return apiKey ? HttpClientRequest.setHeader(request, BYOK_HEADER, apiKey) : request;
+	}));
+}));
+//#endregion
+//#region src/LayerSpec.ts
+var LayerSpec_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	make: () => make$2
+});
+var TypeId = "~@dxos/functions/LayerSpec";
+/**
+* Make a service.
+*/
+var make$2 = (opts, make) => {
+	return {
+		[TypeId]: TypeId,
+		affinity: opts.affinity,
+		requires: opts.requires,
+		provides: opts.provides,
+		make
+	};
+};
+//#endregion
+//#region src/OperationRegistry.ts
+var OperationRegistry_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	layer: () => layer,
+	resolve: () => resolve$1
+});
+var Service = class extends Context.Tag("@dxos/operation/OperationRegistry")() {};
+/**
+* Resolve an operation by key.
+*/
+var resolve$1 = 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.query(Query.select(Filter.and(Filter.type(PersistentOperation), Filter.key(key)))).first.pipe(Effect.flatten, Effect.map(deserialize), Effect.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key)), Effect.option).pipe(Effect.provideService(Database.Service, database)) };
+}));
+//#endregion
+//#region src/Trace.ts
+var Trace_exports = /* @__PURE__ */ __exportAll({
+	CommonRuntimeName: () => CommonRuntimeName,
+	Event: () => Event,
+	EventType: () => EventType,
+	Message: () => Message,
+	MessageData: () => MessageData,
+	Meta: () => Meta,
+	OperationEnd: () => OperationEnd,
+	OperationInput: () => OperationInput,
+	OperationOutput: () => OperationOutput,
+	OperationStart: () => OperationStart,
+	RuntimeName: () => RuntimeName,
+	StatusUpdate: () => StatusUpdate,
+	TRACE_MESSAGE_TYPE_URL: () => TRACE_MESSAGE_TYPE_URL,
+	TraceService: () => TraceService,
+	TraceSink: () => TraceSink,
+	decodeTraceMessage: () => decodeTraceMessage,
+	emitStatus: () => emitStatus,
+	encodeTraceMessage: () => encodeTraceMessage,
+	flatten: () => flatten,
+	isEdgeRuntime: () => isEdgeRuntime,
+	isOfType: () => isOfType,
+	layerConsole: () => layerConsole,
+	layerNoop: () => layerNoop,
+	matchesFilter: () => matchesFilter,
+	mergeSinks: () => mergeSinks,
+	messageToTags: () => messageToTags,
+	noopSink: () => noopSink,
+	noopWriter: () => noopWriter,
+	subscriptionTagForFilter: () => subscriptionTagForFilter,
+	testTraceService: () => testTraceService,
+	write: () => write,
+	writerLayerNoop: () => writerLayerNoop
+});
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
+/**
+* Service that writes events to the trace.
+* Exposed to processes and operations to record events to the trace.
+*/
+var TraceService = class extends Context.Tag("@dxos/functions/TraceService")() {};
+/**
+* Writes an event to the trace.
+*/
+function write(eventType, payload) {
+	return Effect.gen(function* () {
+		log("trace write", {
+			key: eventType.key,
+			isEphemeral: eventType.isEphemeral
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 37,
+			S: this
+		});
+		(yield* TraceService).write(eventType, payload);
+	});
+}
+var EventType = (key, opts) => {
+	return {
+		key,
+		schema: opts.schema,
+		isEphemeral: opts.isEphemeral
+	};
+};
+var Event = Schema.Struct({
+	timestamp: Schema.Number,
+	type: Schema.String,
+	data: Schema.Unknown
+});
+/**
+* Checks if an event is of a given type.
+*/
+var isOfType = (eventType, event) => {
+	return event.type === eventType.key;
+};
+/**
+* Extensible name informing which runtime executed the code that produced the event.
+*/
+var RuntimeName = Schema.String.pipe(Schema.brand("@dxos/compute/Trace/RuntimeName"));
+/**
+* Common runtime names.
+*/
+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")
+};
+/**
+* Metadata on the context of a trace message.
+*/
+var Meta = Schema.Struct({
+	pid: Schema.optional(Schema.String),
+	parentPid: Schema.optional(Schema.String),
+	processName: Schema.optional(Schema.String),
+	/**
+	* Space the message was produced in.
+	* Stored as a string to avoid circular dependency on `@dxos/keys`.
+	*/
+	space: Schema.optional(Schema.String),
+	/**
+	* Ref to the conversation feed object if present.
+	*/
+	conversation: Ref.Ref(Obj.Unknown).pipe(Schema.optional),
+	/**
+	* Ref to the trigger object if invocation resulted from a trigger.
+	*/
+	trigger: Ref.Ref(Trigger).pipe(Schema.optional),
+	/**
+	* ID of the tool call that created the current process.
+	*/
+	toolCallId: Schema.optional(Schema.String),
+	/**
+	* Extensible name informing which runtime executed the code that produced the event.
+	*/
+	runtimeName: Schema.optional(RuntimeName)
+});
+/**
+* Checks if a runtime is an edge runtime.
+*/
+var isEdgeRuntime = (name) => name === CommonRuntimeName.edgeIntrinsic || name === CommonRuntimeName.edgeWorkerLoader || name === CommonRuntimeName.edgeWorkerForPlatforms;
+/**
+* Envelope for a set of events.
+*/
+var MessageData = Schema.Struct({
+	meta: Meta,
+	isEphemeral: Schema.Boolean,
+	events: Schema.Array(Event)
+});
+var Message = class extends Type.makeObject(DXN.make("org.dxos.type.traceMessage", "0.1.0"))(MessageData.pipe(Annotation.IconAnnotation.set({
+	icon: "ph--note--regular",
+	hue: "rose"
+}), Annotation.HiddenAnnotation.set(true))) {};
+/**
+* Flattens a trace message into a list of flat events.
+*/
+var flatten = (message) => {
+	return message.events.map((event) => ({
+		...event,
+		meta: message.meta,
+		isEphemeral: message.isEphemeral
+	}));
+};
+/**
+* `google.protobuf.Any` type URL for a trace message broadcast over the swarm.
+*/
+var TRACE_MESSAGE_TYPE_URL = "dxos.compute.TraceMessage";
+/**
+* Derive the flat broadcast tag list for a message (DX-1125). The publisher emits all applicable tags;
+* subscribers match a subset (logical OR).
+*/
+var messageToTags = (message) => {
+	const { meta } = message;
+	const tags = [];
+	for (const event of message.events) tags.push(`type:${event.type}`);
+	if (meta.pid) tags.push(`pid:${meta.pid}`);
+	if (meta.parentPid) tags.push(`parentPid:${meta.parentPid}`);
+	if (meta.conversation) tags.push(`conversation:${meta.conversation.uri.toString()}`);
+	if (meta.trigger) tags.push(`trigger:${meta.trigger.uri.toString()}`);
+	if (meta.space) tags.push(`space:${meta.space}`);
+	if (meta.runtimeName) tags.push(`runtime:${meta.runtimeName}`);
+	if (meta.toolCallId) tags.push(`toolCall:${meta.toolCallId}`);
+	return tags;
+};
+/**
+* Pick the coarse subscription tag for a filter (DX-1125). The swarm cuts traffic to a superset of the
+* filter using its most selective present dimension; the client re-applies the exact filter.
+*/
+var subscriptionTagForFilter = (filter) => {
+	if (filter.conversation !== void 0) return `conversation:${filter.conversation}`;
+	if (filter.trigger !== void 0) return `trigger:${filter.trigger}`;
+	if (filter.parentPid !== void 0) return `parentPid:${filter.parentPid}`;
+	if (filter.pid !== void 0) return `pid:${filter.pid}`;
+	if (filter.space !== void 0) return `space:${filter.space}`;
+	if (filter.type !== void 0) return `type:${filter.type}`;
+};
+/**
+* Exact (AND) filter match applied client-side after the coarse swarm subscription.
+*/
+var matchesFilter = (message, filter) => {
+	const { meta } = message;
+	if (filter.type !== void 0 && !message.events.some((event) => event.type === filter.type)) return false;
+	if (filter.pid !== void 0 && meta.pid !== filter.pid) return false;
+	if (filter.parentPid !== void 0 && meta.parentPid !== filter.parentPid) return false;
+	if (filter.conversation !== void 0 && meta.conversation?.uri.toString() !== filter.conversation) return false;
+	if (filter.trigger !== void 0 && meta.trigger?.uri.toString() !== filter.trigger) return false;
+	if (filter.space !== void 0 && meta.space !== filter.space) return false;
+	if (filter.runtimeName !== void 0 && meta.runtimeName !== filter.runtimeName) return false;
+	if (filter.toolCallId !== void 0 && meta.toolCallId !== filter.toolCallId) return false;
+	return true;
+};
+/**
+* Wire-safe subset of {@link Meta} for broadcast. Ref fields (`conversation`, `trigger`) are not
+* carried in the payload — they are represented only as envelope tags — so the decoded message never
+* attempts ref resolution on the consumer.
+*/
+var encodeMetaForWire = (meta) => ({
+	pid: meta.pid,
+	parentPid: meta.parentPid,
+	processName: meta.processName,
+	space: meta.space,
+	toolCallId: meta.toolCallId,
+	runtimeName: meta.runtimeName
+});
+/**
+* Encode a trace message for the broadcast envelope's `google.protobuf.Any.value` (DX-1125).
+* The wire format is UTF-8 JSON of the message data (ref fields dropped — see {@link encodeMetaForWire}).
+*/
+var encodeTraceMessage = (message) => new TextEncoder().encode(JSON.stringify({
+	meta: encodeMetaForWire(message.meta),
+	isEphemeral: message.isEphemeral,
+	events: message.events
+}));
+/**
+* Decode a broadcast trace message back into a {@link Message} object (DX-1125). The wire payload
+* drops both ref meta fields (see {@link encodeMetaForWire}), so `tags` — the broadcast envelope's
+* tag list — is required to restore them: `trigger` addresses work for cancellation, and
+* `conversation` is what {@link matchesFilter} compares, so a subscription filtered by it matches
+* nothing without this. Restored refs are address-only (`.uri`); they are never resolved.
+*/
+var decodeTraceMessage = (bytes, tags) => {
+	const parsed = JSON.parse(new TextDecoder().decode(bytes));
+	const meta = parsed.meta ?? {};
+	const conversation = meta.conversation ?? refFromTags(tags, "conversation:");
+	const trigger = meta.trigger ?? refFromTags(tags, "trigger:");
+	return Obj.make(Message, {
+		meta: {
+			...meta,
+			...conversation ? { conversation } : {},
+			...trigger ? { trigger } : {}
+		},
+		isEphemeral: parsed.isEphemeral ?? true,
+		events: parsed.events ?? []
+	});
+};
+/** The ref carried on a broadcast envelope's `<prefix><uri>` tag, when present and parseable. */
+var refFromTags = (tags, prefix) => {
+	const uri = tags?.find((tag) => tag.startsWith(prefix))?.slice(prefix.length);
+	const eid = uri !== void 0 ? EID.tryParse(uri) : void 0;
+	return eid !== void 0 ? Ref.fromURI(eid) : void 0;
+};
+/**
+* Sink for complete trace messages.
+* The Process Manager forwards trace messages to it.
+*/
+var TraceSink = class extends Context.Tag("@dxos/functions/TraceSink")() {};
+var noopWriter = { write: () => {} };
+var writerLayerNoop = Layer.succeed(TraceService, noopWriter);
+var noopSink = { write: () => {} };
+var layerNoop = Layer.succeed(TraceSink, noopSink);
+var layerConsole = Layer.succeed(TraceSink, { write: (message) => {
+	console.log(message);
+} });
+/**
+* Merge a set of sinks into a single sink.
+*
+* Each message is forwarded to every sink in order. Failures in one sink do not
+* prevent downstream sinks from receiving the 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);
+		}
+	} };
+};
+/**
+* Builds a {@link TraceService} layer that wraps each `write` into a fresh {@link Message}
+* and forwards it to the provided {@link TraceSink}. Intended for tests and lightweight
+* fixtures.
+*
+* Options:
+*   - `meta`: stamped on every emitted message (defaults to `{}`).
+*   - `clock`: timestamp source (defaults to {@link Date.now}). Pass a monotonic counter
+*     in tests to make event ordering deterministic when many writes happen in the same
+*     millisecond.
+*/
+var testTraceService = (opts = {}) => Layer.effect(TraceService, Effect.gen(function* () {
+	const sink = yield* TraceSink;
+	const clock = opts.clock ?? Date.now;
+	return { write: (event, data) => {
+		sink.write(Obj.make(Message, {
+			meta: opts.meta ?? {},
+			isEphemeral: event.isEphemeral,
+			events: [{
+				type: event.key,
+				timestamp: clock(),
+				data
+			}]
+		}));
+	} };
+}));
+/**
+* Operation invocation started.
+*/
+var OperationStart = EventType("operation.start", {
+	schema: Schema.Struct({
+		/** Operation key. */
+		key: Schema.String,
+		/** Human-readable operation name. */
+		name: Schema.optional(Schema.String),
+		/** Phosphor icon identifier in `ph--<name>--<variant>` format. */
+		icon: Schema.optional(Schema.String)
+	}),
+	isEphemeral: false
+});
+/**
+* Operation invocation ended.
+*/
+var OperationEnd = EventType("operation.end", {
+	schema: Schema.Struct({
+		/** Operation key. */
+		key: Schema.String,
+		/** Human-readable operation name. */
+		name: Schema.optional(Schema.String),
+		/** Phosphor icon identifier in `ph--<name>--<variant>` format. */
+		icon: Schema.optional(Schema.String),
+		/** Outcome of the operation. */
+		outcome: Schema.Literal("success", "failure"),
+		/** Error message if the operation failed. */
+		error: Schema.optional(Schema.String)
+	}),
+	isEphemeral: false
+});
+/**
+* Operation input. Emitted as an ephemeral event alongside {@link OperationStart}
+* so subscribers (such as the undo/redo history tracker) can observe the raw
+* input payload without persisting it to long-lived sinks.
+*/
+var OperationInput = EventType("operation.input", {
+	schema: Schema.Struct({
+		/** Operation key. */
+		key: Schema.String,
+		/** Human-readable operation name. */
+		name: Schema.optional(Schema.String),
+		/** Raw operation input. Shape determined by the operation definition. */
+		input: Schema.Unknown
+	}),
+	isEphemeral: true
+});
+/**
+* Operation output. Emitted as an ephemeral event just before
+* {@link OperationEnd} for successful invocations so subscribers (such as the
+* undo/redo history tracker) can observe the raw output payload without
+* persisting it to long-lived sinks.
+*/
+var OperationOutput = EventType("operation.output", {
+	schema: Schema.Struct({
+		/** Operation key. */
+		key: Schema.String,
+		/** Human-readable operation name. */
+		name: Schema.optional(Schema.String),
+		/** Raw operation output. Shape determined by the operation definition. */
+		output: Schema.Unknown
+	}),
+	isEphemeral: true
+});
+/**
+* Human-readable status update emitted by an agent or operation.
+*/
+var StatusUpdate = EventType("status.update", {
+	schema: Schema.Struct({
+		/** Human-readable status message.. */
+		message: Schema.optional(Schema.String),
+		progress: Schema.optional(Schema.Struct({
+			/** Progress key. See {@link ProgressRegistry.key}. */
+			key: Schema.String,
+			current: Schema.optional(Schema.Number),
+			/** Progress total item count. */
+			total: Schema.optional(Schema.Number),
+			/** Progress estimate of remaining time (ms). */
+			estimate: Schema.optional(Schema.Number)
+		}))
+	}),
+	isEphemeral: true
+});
+/**
+* Emit the current human-readable execution status to the trace.
+*/
+var emitStatus = (message) => write(StatusUpdate, typeof message === "string" ? { message } : message);
+//#endregion
+//#region src/Process.ts
+var Process_exports = /* @__PURE__ */ __exportAll({
+	ExitedEvent: () => ExitedEvent,
+	HarnessHostAnnotation: () => HarnessHostAnnotation,
+	ID: () => ID,
+	InstructionsAnnotation: () => InstructionsAnnotation,
+	NotifyAnnotation: () => NotifyAnnotation,
+	ProcessMonitorService: () => ProcessMonitorService,
+	ProcessTypeId: () => ProcessTypeId,
+	SpawnedEvent: () => SpawnedEvent,
+	State: () => State,
+	TargetAnnotation: () => TargetAnnotation,
+	fromOperation: () => fromOperation,
+	isProcess: () => isProcess,
+	make: () => make$1,
+	prettyProcessTree: () => prettyProcessTree
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
+/** Opaque process id (arbitrary string). */
+var ID = Schema.String.pipe(Schema.brand("ProcessId"));
+/**
+* Attaches the process to a target object.
+*/
+var TargetAnnotation = Annotation.make({
+	id: "org.dxos.process.target",
+	schema: URI$1.Schema
+});
+/**
+* Notification descriptor for surfacing process lifecycle events to the user.
+*/
+var NotifyAnnotation = Annotation.make({
+	id: "org.dxos.process.notify",
+	schema: NotifyOptions
+});
+/**
+* URI of the Instructions object steering the process's conversation. Persisted at spawn (like
+* {@link TargetAnnotation}) so a re-hydrated process recovers its steering without reaching the Chat.
+*/
+var InstructionsAnnotation = Annotation.make({
+	id: "org.dxos.process.instructions",
+	schema: URI$1.Schema
+});
+/**
+* Marks a process as the harness host for its conversation (discovery substrate).
+*/
+var HarnessHostAnnotation = Annotation.make({
+	id: "org.dxos.process.harnessHost",
+	schema: Schema.Boolean
+});
+var ProcessTypeId = "~@dxos/functions/Process";
+var isProcess = (executable) => typeof executable === "object" && executable !== null && "~@dxos/functions/Process" in executable;
+var make$1 = (opts, create) => {
+	assertArgument(/^[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(Effect.map((partial) => ({
+			onSpawn: () => Effect.void,
+			onInput: () => Effect.void,
+			onAlarm: () => Effect.void,
+			onChildEvent: () => Effect.void,
+			...partial,
+			rpcHandlers: sanitizeRpcs(opts.rpcs, partial.rpcHandlers)
+		})))
+	};
+};
+var sanitizeRpcs = (defined, provided) => {
+	if (!(defined !== void 0 && defined.requests.size > 0)) return provided ?? Context.empty();
+	if (!provided) throw new TypeError("Process declared RPCs but did not provide any handlers");
+	return provided;
+};
+/**
+* Durable marker recording that an operation's input handler has begun executing.
+* Persisted before the handler runs so that, after an interruption (suspend/restart), a
+* re-delivered input can tell that the previous attempt was in-flight. Cleared automatically
+* when the process reaches a terminal state (the runtime clears the process's storage).
+*/
+var OperationStartedCell = cell(Schema.parseJson(Schema.Boolean), "operation/started").pipe(withDefault(() => false));
+var fromOperation = (op, handler) => make$1({
+	key: DXN$1.getName(op.meta.key),
+	input: op.input,
+	output: op.output,
+	services: op.services
+}, (ctx) => Effect.gen(function* () {
+	const semaphore = yield* Effect.makeSemaphore(1);
+	const idempotent = isIdempotent(op);
+	return { onInput: (input) => Effect.gen(function* () {
+		if (!idempotent) {
+			if (yield* OperationStartedCell.get) return yield* Effect.die(/* @__PURE__ */ new Error(`non-idempotent operation "${op.meta.key}" was interrupted; cannot retry safely`));
+			yield* OperationStartedCell.set(true);
+		}
+		log("operation process invoking", {
+			key: op.meta.key,
+			name: op.meta.name
+		}, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 375,
+			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 output = yield* (yield* getHandler(handler, op).pipe(Effect.orDie)).handler(input).pipe(Effect.orDie, Effect.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(Effect.catchAllDefect((defect) => Effect.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* Effect.die(defect);
+	})), semaphore.withPermits(1)) };
+}));
+/**
+* Runtime state of a process.
+*/
+var State = /* @__PURE__ */ function(State) {
+	State["RUNNING"] = "RUNNING";
+	State["HYBERNATING"] = "HYBERNATING";
+	State["IDLE"] = "IDLE";
+	State["TERMINATING"] = "TERMINATING";
+	State["TERMINATED"] = "TERMINATED";
+	State["SUCCEEDED"] = "SUCCEEDED";
+	State["FAILED"] = "FAILED";
+	return State;
+}({});
+var ProcessMonitorService = class extends Context.Tag("@dxos/functions/ProcessMonitorService")() {};
+/**
+* New process is spawned.
+*/
+var SpawnedEvent = EventType("process.spawned", {
+	schema: Schema.Void,
+	isEphemeral: false
+});
+/**
+* Process has reached a terminal state.
+*/
+var ExitedEvent = EventType("process.exited", {
+	schema: Schema.Struct({ outcome: Schema.Literal("succeeded", "failed", "terminated") }),
+	isEphemeral: false
+});
+/**
+* Renders spawned processes as a forest: top-level rows use "- ", nested rows use ├── / └── / │.
+*/
+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 parts = [String(node.pid).slice(0, 6), node.state];
+		if (node.params.name != null && node.params.name !== "") parts.push(node.params.name);
+		if (node.error != null) parts.push(`(${node.error.message ?? node.error.name ?? "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 ? "└── " : "├── ";
+			lines.push(`${prefix}${branch}${formatLabel(node)}`);
+		}
+		const children = childrenByParent.get(String(node.pid)) ?? [];
+		const nextPrefix = isRoot ? "  " : `${prefix}${isLast ? "    " : "│   "}`;
+		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");
+};
+//#endregion
+//#region src/ServiceResolver.ts
+var ServiceResolver_exports = /* @__PURE__ */ __exportAll({
+	ServiceResolver: () => ServiceResolver,
+	compose: () => compose,
+	empty: () => empty,
+	fromContext: () => fromContext,
+	fromRequirements: () => fromRequirements,
+	layerRequirements: () => layerRequirements,
+	make: () => make,
+	provide: () => provide,
+	resolve: () => resolve,
+	resolveAll: () => resolveAll,
+	succeed: () => succeed
+});
+var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
+/**
+* Tag for the ServiceResolver service.
+*/
+var ServiceResolver = Context.GenericTag("@dxos/functions/ServiceResolver");
+var resolve = Effect.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
+var resolveAll = (tags, context) => Effect.gen(function* () {
+	const services = yield* Effect.forEach(tags, (tag) => resolve(tag, context).pipe(Effect.map((service) => Context.make(tag, service))));
+	return Context.mergeAll(...services);
+});
+var succeed = (tag, getService) => {
+	return make((tag1, context) => {
+		if (tag1.key !== tag.key) return Effect.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
+		return getService(context);
+	});
+};
+/**
+* Create a ServiceResolver from a custom resolution function.
+*/
+var make = (resolveFn) => ({
+	[ServiceResolverTypeId]: ServiceResolverTypeId,
+	resolve: resolveFn
+});
+/**
+* Create a ServiceResolver backed by a static Context.
+* Tags present in the context are resolved; missing tags fail with ServiceNotAvailableError.
+*/
+var fromContext = (ctx) => make((tag, context) => Effect.gen(function* () {
+	const service = Context.getOption(ctx, tag);
+	if (Option.isNone(service)) return yield* Effect.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+	return service.value;
+}));
+/**
+* Create a ServiceResolver that resolves tags from the current Effect context.
+* Only the specified tags are available; requests for other tags fail.
+*/
+var fromRequirements = (...tags) => Effect.contextWith((parentCtx) => {
+	const available = new Set(tags.map((tag) => tag.key));
+	return make((tag, context) => Effect.gen(function* () {
+		Context.empty();
+		if (!available.has(tag.key)) return yield* Effect.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+		const service = Context.getOption(parentCtx, tag);
+		if (Option.isNone(service)) return yield* Effect.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+		return service.value;
+	}));
+});
+/**
+* Like {@link fromRequirements} but returns a Layer that provides ServiceResolver.
+*/
+var layerRequirements = (...tags) => Layer.effect(ServiceResolver, fromRequirements(...tags));
+/**
+* Build a {@link Layer} that materialises the requested services by calling
+* {@link resolveAll} against the {@link ServiceResolver} currently in context.
+*
+* The returned layer manages its own {@link Scope.Scope} and requires only a
+* {@link ServiceResolver} (typically supplied by the process-manager runtime).
+*
+* @example
+* ```ts
+* processManagerRuntime.runPromise(
+*   myEffect.pipe(Effect.provide(ServiceResolver.provide({ space }, Database.Service))),
+* );
+* ```
+*/
+var provide = (context, ...tags) => Layer.scopedContext(resolveAll(tags, context));
+/**
+* Compose multiple resolvers left to right. Earlier resolvers take precedence:
+* the first resolver that can satisfy a tag wins.
+*/
+var compose = (...resolvers) => make((tag, context) => Effect.gen(function* () {
+	for (const resolver of resolvers) {
+		const single = yield* resolver.resolve(tag, context).pipe(Effect.either);
+		if (Either.isRight(single)) return single.right;
+	}
+	return yield* Effect.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+}));
+/**
+* An empty resolver that fails for any requested service.
+*/
+var empty = make((tag, context) => {
+	return Effect.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+});
+//#endregion
+export { AgentIdentity_exports as AgentIdentity, AgentService_exports as AgentService, Cancellation_exports as Cancellation, 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, Project_exports as Project, Routine_exports as Routine, RunAgainError, 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