@dxos/plugin-routine 0.10.0 → 0.11.1

package/dist/lib/chunk-trigger-runtime-controller.mjs

@@ -0,0 +1,73 @@
+import { Capabilities, Capability } from "@dxos/app-framework";
+import { ServiceResolver } from "@dxos/compute";
+import { Obj } from "@dxos/echo";
+import { ClientCapabilities } from "@dxos/plugin-client";
+import * as Effect from "effect/Effect";
+import { TriggerDispatcher } from "@dxos/compute-runtime";
+import { log } from "@dxos/log";
+import * as Fiber from "effect/Fiber";
+//#region src/capabilities/trigger-runtime-controller.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-routine/src/capabilities/trigger-runtime-controller.ts";
+var trigger_runtime_controller_default = Capability.makeModule(Effect.fnUntraced(function* () {
+	const client = yield* Capability.get(ClientCapabilities.Client);
+	const runtime = yield* Capability.get(Capabilities.ProcessManagerRuntime);
+	const trackers = /* @__PURE__ */ new Map();
+	/**
+	* Resolve the per-space `TriggerDispatcher` from the process-manager
+	* runtime and invoke `start()` / `stop()` according to the requested
+	* disabled state. Returns a fiber so the caller can cancel a pending
+	* transition when a new one supersedes it.
+	*/
+	const transition = (spaceId, disabled) => runtime.runFork(Effect.gen(function* () {
+		const dispatcher = yield* TriggerDispatcher;
+		yield* disabled ? dispatcher.stop() : dispatcher.start();
+	}).pipe(Effect.provide(ServiceResolver.provide({ space: spaceId }, TriggerDispatcher)), Effect.tapErrorCause((cause) => Effect.sync(() => log.warn("trigger dispatcher transition failed", {
+		spaceId,
+		disabled,
+		cause
+	}, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 60,
+		S: this
+	})))));
+	const apply = (tracker, spaceId, disabled) => {
+		if (tracker.lastDisabled === disabled) return;
+		tracker.lastDisabled = disabled;
+		if (tracker.inFlight) runtime.runFork(Fiber.interrupt(tracker.inFlight));
+		tracker.inFlight = transition(spaceId, disabled);
+	};
+	const install = (space) => {
+		if (trackers.has(space.id)) return;
+		const tracker = { unsubscribe: () => {} };
+		trackers.set(space.id, tracker);
+		space.waitUntilReady().then(() => {
+			if (trackers.get(space.id) !== tracker) return;
+			const readDisabled = () => space.properties.triggersDisabled ?? false;
+			tracker.unsubscribe = Obj.subscribe(space.properties, () => apply(tracker, space.id, readDisabled()));
+			apply(tracker, space.id, readDisabled());
+		}).catch((err) => log.catch(err, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 98,
+			S: this
+		}));
+	};
+	const installAll = (spaces) => {
+		for (const space of spaces) install(space);
+	};
+	const spacesSubscription = client.spaces.subscribe(installAll);
+	installAll(client.spaces.get());
+	return Capability.contributes(Capabilities.Null, null, () => Effect.sync(() => {
+		spacesSubscription.unsubscribe();
+		for (const tracker of trackers.values()) {
+			tracker.unsubscribe();
+			if (tracker.inFlight) runtime.runFork(Fiber.interrupt(tracker.inFlight));
+		}
+		trackers.clear();
+	}));
+}));
+//#endregion
+export { trigger_runtime_controller_default as default };
+
+//# sourceMappingURL=chunk-trigger-runtime-controller.mjs.map

package/dist/lib/chunk-trigger-runtime-controller.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-trigger-runtime-controller.mjs","names":[],"sources":["../../src/capabilities/trigger-runtime-controller.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Fiber from 'effect/Fiber';\n\nimport { Capabilities, Capability } from '@dxos/app-framework';\nimport { ServiceResolver } from '@dxos/compute';\nimport { TriggerDispatcher } from '@dxos/compute-runtime';\nimport { Obj } from '@dxos/echo';\nimport { type SpaceId } from '@dxos/keys';\nimport { log } from '@dxos/log';\nimport { ClientCapabilities } from '@dxos/plugin-client';\nimport { type Space } from '@dxos/react-client/echo';\n\n//\n// Capability Module\n//\n// Watches `space.properties.triggersDisabled` for every space and toggles\n// the per-space {@link TriggerDispatcher} accordingly:\n//\n//   - disabled (`true`)        → `dispatcher.stop()`\n//   - enabled (unset/`false`)  → `dispatcher.start()`\n//\n// Per-trigger local/edge routing is handled by the trigger's `remote` flag\n// (the dispatcher skips remote triggers); this space-wide flag is only the\n// kill-switch for local execution. The dispatcher itself is contributed\n// unconditionally via `TriggerDispatcherSpec` in `layer-specs.ts`, so this\n// capability is only responsible for driving its lifecycle.\n//\n\nexport default Capability.makeModule(\n  Effect.fnUntraced(function* () {\n    const client = yield* Capability.get(ClientCapabilities.Client);\n    const runtime = yield* Capability.get(Capabilities.ProcessManagerRuntime);\n\n    /** Per-space property-subscription unsubscribe, last-seen disabled state, and in-flight transition fiber. */\n    type Tracker = {\n      unsubscribe: () => void;\n      lastDisabled?: boolean;\n      inFlight?: Fiber.RuntimeFiber<unknown, unknown>;\n    };\n    const trackers = new Map<SpaceId, Tracker>();\n\n    /**\n     * Resolve the per-space `TriggerDispatcher` from the process-manager\n     * runtime and invoke `start()` / `stop()` according to the requested\n     * disabled state. Returns a fiber so the caller can cancel a pending\n     * transition when a new one supersedes it.\n     */\n    const transition = (spaceId: SpaceId, disabled: boolean) =>\n      runtime.runFork(\n        Effect.gen(function* () {\n          const dispatcher = yield* TriggerDispatcher;\n          yield* disabled ? dispatcher.stop() : dispatcher.start();\n        }).pipe(\n          Effect.provide(ServiceResolver.provide({ space: spaceId }, TriggerDispatcher)),\n          Effect.tapErrorCause((cause) =>\n            Effect.sync(() => log.warn('trigger dispatcher transition failed', { spaceId, disabled, cause })),\n          ),\n        ),\n      );\n\n    const apply = (tracker: Tracker, spaceId: SpaceId, disabled: boolean): void => {\n      if (tracker.lastDisabled === disabled) {\n        return;\n      }\n      tracker.lastDisabled = disabled;\n      if (tracker.inFlight) {\n        runtime.runFork(Fiber.interrupt(tracker.inFlight));\n      }\n      tracker.inFlight = transition(spaceId, disabled);\n    };\n\n    const install = (space: Space): void => {\n      if (trackers.has(space.id)) {\n        return;\n      }\n      // Reserve the slot synchronously so concurrent `client.spaces.subscribe`\n      // notifications (e.g. spaces array churn while we await readiness) don't\n      // wire a second subscriber for the same space.\n      const tracker: Tracker = { unsubscribe: () => {} };\n      trackers.set(space.id, tracker);\n\n      void space\n        .waitUntilReady()\n        .then(() => {\n          // The capability could have been torn down between `set` and the\n          // promise resolving; bail out without subscribing in that case.\n          if (trackers.get(space.id) !== tracker) {\n            return;\n          }\n          const readDisabled = (): boolean => space.properties.triggersDisabled ?? false;\n          tracker.unsubscribe = Obj.subscribe(space.properties, () => apply(tracker, space.id, readDisabled()));\n          apply(tracker, space.id, readDisabled());\n        })\n        .catch((err) => log.catch(err));\n    };\n\n    const installAll = (spaces: readonly Space[]): void => {\n      for (const space of spaces) {\n        install(space);\n      }\n    };\n\n    const spacesSubscription = client.spaces.subscribe(installAll);\n    installAll(client.spaces.get());\n\n    return Capability.contributes(Capabilities.Null, null, () =>\n      Effect.sync(() => {\n        spacesSubscription.unsubscribe();\n        for (const tracker of trackers.values()) {\n          tracker.unsubscribe();\n          if (tracker.inFlight) {\n            runtime.runFork(Fiber.interrupt(tracker.inFlight));\n          }\n        }\n        trackers.clear();\n      }),\n    );\n  }),\n);\n"],"mappings":";;;;;;;;;;AAgCA,IAAA,qCAAe,WAAW,WACxB,OAAO,WAAW,aAAa;CAC7B,MAAM,SAAS,OAAO,WAAW,IAAI,mBAAmB,MAAM;CAC9D,MAAM,UAAU,OAAO,WAAW,IAAI,aAAa,qBAAqB;CAQxE,MAAM,2BAAW,IAAI,IAAsB;;;;;;;CAQ3C,MAAM,cAAc,SAAkB,aACpC,QAAQ,QACN,OAAO,IAAI,aAAa;EACtB,MAAM,aAAa,OAAO;EAC1B,OAAO,WAAW,WAAW,KAAK,IAAI,WAAW,MAAM;CACzD,CAAC,CAAC,CAAC,KACD,OAAO,QAAQ,gBAAgB,QAAQ,EAAE,OAAO,QAAQ,GAAG,iBAAiB,CAAC,GAC7E,OAAO,eAAe,UACpB,OAAO,WAAW,IAAI,KAAK,wCAAwC;EAAE;EAAS;EAAU;CAAM,GAAA;EAAA,YAAA;EAAA,GAAA;EAAA,GAAA;EAAA,GAAA;CAAA,CAAC,CAAC,CAClG,CACF,CACF;CAEF,MAAM,SAAS,SAAkB,SAAkB,aAA4B;EAC7E,IAAI,QAAQ,iBAAiB,UAC3B;EAEF,QAAQ,eAAe;EACvB,IAAI,QAAQ,UACV,QAAQ,QAAQ,MAAM,UAAU,QAAQ,QAAQ,CAAC;EAEnD,QAAQ,WAAW,WAAW,SAAS,QAAQ;CACjD;CAEA,MAAM,WAAW,UAAuB;EACtC,IAAI,SAAS,IAAI,MAAM,EAAE,GACvB;EAKF,MAAM,UAAmB,EAAE,mBAAmB,CAAC,EAAE;EACjD,SAAS,IAAI,MAAM,IAAI,OAAO;EAE9B,MACG,eAAe,CAAA,CACf,WAAW;GAGV,IAAI,SAAS,IAAI,MAAM,EAAE,MAAM,SAC7B;GAEF,MAAM,qBAA8B,MAAM,WAAW,oBAAoB;GACzE,QAAQ,cAAc,IAAI,UAAU,MAAM,kBAAkB,MAAM,SAAS,MAAM,IAAI,aAAa,CAAC,CAAC;GACpG,MAAM,SAAS,MAAM,IAAI,aAAa,CAAC;EACzC,CAAC,CAAA,CACA,OAAO,QAAQ,IAAI,MAAM,KAAE,KAAA,GAAA;GAAA,YAAA;GAAA,GAAA;GAAA,GAAA;GAAA,GAAA;EAAA,CAAC,CAAC;CAClC;CAEA,MAAM,cAAc,WAAmC;EACrD,KAAK,MAAM,SAAS,QAClB,QAAQ,KAAK;CAEjB;CAEA,MAAM,qBAAqB,OAAO,OAAO,UAAU,UAAU;CAC7D,WAAW,OAAO,OAAO,IAAI,CAAC;CAE9B,OAAO,WAAW,YAAY,aAAa,MAAM,YAC/C,OAAO,WAAW;EAChB,mBAAmB,YAAY;EAC/B,KAAK,MAAM,WAAW,SAAS,OAAO,GAAG;GACvC,QAAQ,YAAY;GACpB,IAAI,QAAQ,UACV,QAAQ,QAAQ,MAAM,UAAU,QAAQ,QAAQ,CAAC;EAErD;EACA,SAAS,MAAM;CACjB,CAAC,CACH;AACF,CAAC,CACH"}

package/dist/lib/chunk-types.mjs

@@ -0,0 +1,149 @@
+import { Capability } from "@dxos/app-framework";
+import { Instructions, Operation, Routine, Trigger } from "@dxos/compute";
+import { meta } from "#meta";
+import * as Schema from "effect/Schema";
+import { DXN, Database, Obj, Ref, Type } from "@dxos/echo";
+import { Chat } from "@dxos/assistant-toolkit";
+import { EID as _EchoURIReference } from "@dxos/keys";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/types/schema.ts
+var TriggerTemplate = Schema.Union(Schema.Struct({
+	type: Schema.Literal("timer"),
+	cron: Schema.String
+}), Schema.Struct({
+	type: Schema.Literal("feed"),
+	feed: Schema.Any
+}));
+var AutomationAction;
+(function(_AutomationAction) {
+	class CreateTriggerFromTemplate extends Schema.TaggedClass()(`${meta.profile.key}.action.create-trigger-from-template`, {
+		input: Schema.Struct({
+			db: Database.Database,
+			template: TriggerTemplate,
+			enabled: Schema.optional(Schema.Boolean),
+			scriptName: Schema.optional(Schema.String),
+			input: Schema.optional(Schema.Record({
+				key: Schema.String,
+				value: Schema.Any
+			}))
+		}),
+		output: Schema.Void
+	}) {}
+	_AutomationAction.CreateTriggerFromTemplate = CreateTriggerFromTemplate;
+})(AutomationAction || (AutomationAction = {}));
+//#endregion
+//#region src/types/RoutineCapabilities.ts
+var RoutineCapabilities_exports = /* @__PURE__ */ __exportAll({
+	AgentDelegationStrategy: () => AgentDelegationStrategy,
+	BlankTemplateId: () => BlankTemplateId,
+	Template: () => Template
+});
+/**
+* Optional supervisor strategy for the agent chat service. When contributed (by a plugin that knows
+* the agent/plan model, e.g. plugin-assistant), the conversational agent delegates outstanding work
+* to sub-agents and folds their results back into the conversation. Consumed by the AgentService
+* LayerSpec; absent by default (a plain conversational agent).
+*/
+var AgentDelegationStrategy = Capability.make("org.dxos.plugin.routine.capability.agentDelegationStrategy");
+/**
+* Id of the built-in blank template. Declared here (rather than on the template itself) so callers that
+* scaffold a routine without the picker — e.g. a project's toolbar — can name it without importing the
+* template module.
+*/
+var BlankTemplateId = "org.dxos.routine.blank";
+var Template = Capability.make("org.dxos.plugin.routine.capability.template");
+//#endregion
+//#region src/types/RoutineOperation.ts
+var RoutineOperation_exports = /* @__PURE__ */ __exportAll({
+	CreateRoutine: () => CreateRoutine,
+	CreateTriggerFromTemplate: () => CreateTriggerFromTemplate,
+	RunPromptInNewChat: () => RunPromptInNewChat,
+	RunRoutine: () => RunRoutine,
+	_EchoURIReference: () => _EchoURIReference
+});
+var makeKey = (name) => DXN.make(`${meta.profile.key}.operation.${name}`);
+var CreateTriggerFromTemplate = Operation.make({
+	meta: {
+		key: makeKey("createTriggerFromTemplate"),
+		name: "Create Trigger From Template",
+		icon: "ph--lightning--regular"
+	},
+	services: [Capability.Service],
+	input: Schema.Struct({
+		db: Database.Database,
+		template: TriggerTemplate,
+		enabled: Schema.optional(Schema.Boolean),
+		scriptName: Schema.optional(Schema.String),
+		input: Schema.optional(Schema.Record({
+			key: Schema.String,
+			value: Schema.Any
+		}))
+	}),
+	output: Schema.Void
+});
+var CreateRoutine = Operation.make({
+	meta: {
+		key: makeKey("createAutomation"),
+		name: "Create Routine",
+		icon: "ph--lightning--regular"
+	},
+	services: [Capability.Service],
+	input: Schema.Struct({
+		db: Database.Database,
+		templateId: Schema.String,
+		name: Schema.optional(Schema.String),
+		subject: Schema.optional(Obj.Unknown)
+	}),
+	output: Schema.Struct({
+		id: Schema.String,
+		subject: Schema.Array(Schema.String),
+		object: Obj.Unknown
+	})
+});
+var RunPromptInNewChat = Operation.make({
+	meta: {
+		key: makeKey("runPromptInNewChat"),
+		name: "Run Prompt In New Chat",
+		icon: "ph--chat-text--regular"
+	},
+	services: [Capability.Service],
+	input: Schema.Struct({
+		db: Database.Database,
+		/** Context objects to bind to the new chat. */
+		objects: Schema.optional(Schema.Array(Obj.Unknown)),
+		/** Skill keys to look up and bind to the new chat. */
+		skills: Schema.optional(Schema.Array(Schema.String)),
+		/** Raw instructions or an existing Routine object reference. */
+		instructions: Schema.Union(Schema.String, Ref.Ref(Instructions.Instructions)),
+		/**
+		* When true, skips opening the chat: runs the Agent prompt operation against the new chat via the compute runtime (traced).
+		*/
+		background: Schema.optional(Schema.Boolean)
+	}),
+	output: Schema.Struct({ object: Type.getSchema(Chat.Chat) })
+});
+var RunRoutine = Operation.make({
+	meta: {
+		key: makeKey("runAutomation"),
+		name: "Run Routine",
+		icon: "ph--play--regular"
+	},
+	services: [Capability.Service, Trigger.TriggerMonitorService],
+	input: Schema.Struct({ routine: Ref.Ref(Routine.Routine) }),
+	output: Schema.Void
+});
+//#endregion
+export { RoutineCapabilities_exports as a, TriggerTemplate as c, RunRoutine as i, CreateTriggerFromTemplate as n, Template as o, RoutineOperation_exports as r, AutomationAction as s, CreateRoutine as t };
+
+//# sourceMappingURL=chunk-types.mjs.map

package/dist/lib/chunk-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-types.mjs","names":[],"sources":["../../src/types/schema.ts","../../src/types/RoutineCapabilities.ts","../../src/types/RoutineOperation.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { Database } from '@dxos/echo';\n\nimport { meta } from '#meta';\n\nexport const TriggerTemplate = Schema.Union(\n  Schema.Struct({ type: Schema.Literal('timer'), cron: Schema.String }),\n  Schema.Struct({ type: Schema.Literal('feed'), feed: Schema.Any }),\n);\n\nexport namespace AutomationAction {\n  export class CreateTriggerFromTemplate extends Schema.TaggedClass<CreateTriggerFromTemplate>()(\n    `${meta.profile.key}.action.create-trigger-from-template`,\n    {\n      input: Schema.Struct({\n        db: Database.Database,\n        template: TriggerTemplate,\n        enabled: Schema.optional(Schema.Boolean),\n        // TODO(wittjosiah): Improve how this lookup is done.\n        scriptName: Schema.optional(Schema.String),\n        input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),\n      }),\n      output: Schema.Void,\n    },\n  ) {}\n}\n","//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Effect from 'effect/Effect';\n\nimport type { DelegationStrategy } from '@dxos/agent-runtime';\nimport { Capability } from '@dxos/app-framework';\nimport type { Routine } from '@dxos/compute';\nimport type { Database, Obj } from '@dxos/echo';\n\n/**\n * Optional supervisor strategy for the agent chat service. When contributed (by a plugin that knows\n * the agent/plan model, e.g. plugin-assistant), the conversational agent delegates outstanding work\n * to sub-agents and folds their results back into the conversation. Consumed by the AgentService\n * LayerSpec; absent by default (a plain conversational agent).\n */\nexport const AgentDelegationStrategy = Capability.make<DelegationStrategy>(\n  'org.dxos.plugin.routine.capability.agentDelegationStrategy',\n);\n\n/**\n * Id of the built-in blank template. Declared here (rather than on the template itself) so callers that\n * scaffold a routine without the picker — e.g. a project's toolbar — can name it without importing the\n * template module.\n */\nexport const BlankTemplateId = 'org.dxos.routine.blank';\n\n/**\n * An automation template contributed by a plugin. The create dialog and the per-object \"Automations\"\n * companion list contributed templates (`Capability.getAll(RoutineCapabilities.Template)`) and run the\n * chosen template's `scaffold` to build the automation.\n */\nexport type Template = {\n  /** Stable id (e.g. 'org.dxos.routine.blank'). */\n  id: string;\n  /** Human-readable label shown in the picker. */\n  label: string;\n  /** Optional Phosphor icon name. */\n  icon?: string;\n  /**\n   * Whether this template applies to the given companion subject. The subject is the object whose\n   * \"Automations\" companion is open, or undefined in the global create dialog. Templates that need a\n   * specific subject (e.g. a feed-bearing Mailbox) gate themselves here. Defaults to always-applies.\n   */\n  appliesTo?: (subject?: Obj.Unknown) => boolean;\n  /**\n   * Build the routine as a fully-wired in-memory {@link Routine.Routine} graph — the routine plus its owned\n   * trigger and instructions, assembled by `makeRoutine`. The create flow persists it with a single\n   * `Database.add` (which cascades the owned children); scaffold must NOT call `Database.add` itself.\n   * `Database.Service` may still be used for read-only lookups (e.g. loading a feed ref). `subject` is set\n   * when scaffolding from an object's companion.\n   */\n  scaffold: (ctx: { name?: string; subject?: Obj.Unknown }) => Effect.Effect<Routine.Routine, Error, Database.Service>;\n};\n\nexport const Template = Capability.make<Template>('org.dxos.plugin.routine.capability.template');\n","//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Capability } from '@dxos/app-framework';\nimport { Chat } from '@dxos/assistant-toolkit';\nimport { Instructions, Operation, Routine, Trigger } from '@dxos/compute';\nimport { Database, DXN, Obj, Ref, Type } from '@dxos/echo';\n// Value-side `EID` import keeps TS declaration emit portable — `TriggerTemplate`\n// references `EID.Schema` and the inferred `CreateTriggerFromTemplate` type\n// otherwise needs a transitive `@dxos/keys` import that's hard for d.ts emit to surface.\nimport { EID as _EchoURIReference } from '@dxos/keys';\n\nimport { meta } from '#meta';\n\nimport { TriggerTemplate } from './schema';\nexport { _EchoURIReference };\n\nconst makeKey = (name: string) => DXN.make(`${meta.profile.key}.operation.${name}`);\n\nexport const CreateTriggerFromTemplate = Operation.make({\n  meta: {\n    key: makeKey('createTriggerFromTemplate'),\n    name: 'Create Trigger From Template',\n    icon: 'ph--lightning--regular',\n  },\n  services: [Capability.Service],\n  input: Schema.Struct({\n    db: Database.Database,\n    template: TriggerTemplate,\n    enabled: Schema.optional(Schema.Boolean),\n    scriptName: Schema.optional(Schema.String),\n    input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),\n  }),\n  output: Schema.Void,\n});\n\n// The single creation entrypoint for every path (create dialog, companion, sidebar) so placement and\n// ownership are established in one place. Output mirrors `SpaceCapabilities.CreateObjectResult`.\nexport const CreateRoutine = Operation.make({\n  meta: {\n    key: makeKey('createAutomation'),\n    name: 'Create Routine',\n    icon: 'ph--lightning--regular',\n  },\n  services: [Capability.Service],\n  input: Schema.Struct({\n    db: Database.Database,\n    templateId: Schema.String,\n    name: Schema.optional(Schema.String),\n    subject: Schema.optional(Obj.Unknown),\n  }),\n  output: Schema.Struct({\n    id: Schema.String,\n    subject: Schema.Array(Schema.String),\n    object: Obj.Unknown,\n  }),\n});\n\nexport const RunPromptInNewChat = Operation.make({\n  meta: {\n    key: makeKey('runPromptInNewChat'),\n    name: 'Run Prompt In New Chat',\n    icon: 'ph--chat-text--regular',\n  },\n  services: [Capability.Service],\n  input: Schema.Struct({\n    db: Database.Database,\n    /** Context objects to bind to the new chat. */\n    objects: Schema.optional(Schema.Array(Obj.Unknown)),\n    /** Skill keys to look up and bind to the new chat. */\n    skills: Schema.optional(Schema.Array(Schema.String)),\n    /** Raw instructions or an existing Routine object reference. */\n    instructions: Schema.Union(Schema.String, Ref.Ref(Instructions.Instructions)),\n    /**\n     * When true, skips opening the chat: runs the Agent prompt operation against the new chat via the compute runtime (traced).\n     */\n    background: Schema.optional(Schema.Boolean),\n  }),\n  output: Schema.Struct({\n    object: Type.getSchema(Chat.Chat),\n  }),\n});\n\n// Runs a routine's action now, routed by its first trigger — that is where both the runnable's input\n// (e.g. a sync routine's binding cursor) and the `remote` flag live. A `remote` trigger force-runs on the\n// EDGE dispatcher over HTTP, since that is the only runtime it is registered on; a local one runs\n// in-process. Without the trigger a manual run would invoke an input-taking runnable with nothing, and\n// would silently run an edge routine on the client.\nexport const RunRoutine = Operation.make({\n  meta: {\n    key: makeKey('runAutomation'),\n    name: 'Run Routine',\n    icon: 'ph--play--regular',\n  },\n  services: [Capability.Service, Trigger.TriggerMonitorService],\n  input: Schema.Struct({\n    routine: Ref.Ref(Routine.Routine),\n  }),\n  output: Schema.Void,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAUA,IAAa,kBAAkB,OAAO,MACpC,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,OAAO;CAAG,MAAM,OAAO;AAAO,CAAC,GACpE,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,MAAM;CAAG,MAAM,OAAO;AAAI,CAAC,CAClE;AAEO,IAAA;;CACE,MAAM,kCAAkC,OAAO,YAAuC,CAAC,CAC5F,GAAG,KAAK,QAAQ,IAAI,uCACpB;EACE,OAAO,OAAO,OAAO;GACnB,IAAI,SAAS;GACb,UAAU;GACV,SAAS,OAAO,SAAS,OAAO,OAAO;GAEvC,YAAY,OAAO,SAAS,OAAO,MAAM;GACzC,OAAO,OAAO,SAAS,OAAO,OAAO;IAAE,KAAK,OAAO;IAAQ,OAAO,OAAO;GAAI,CAAC,CAAC;EACjF,CAAC;EACD,QAAQ,OAAO;CACjB,CACF,CAAC,CAAC,CAAC;;GACL,qBAAA,mBAAA,CAAA,EAAA;;;;;;;;;;;;;;ACbA,IAAa,0BAA0B,WAAW,KAChD,4DACF;;;;;;AAOA,IAAa,kBAAkB;AA8B/B,IAAa,WAAW,WAAW,KAAe,6CAA6C;;;;;;;;;;AClC/F,IAAM,WAAW,SAAiB,IAAI,KAAK,GAAG,KAAK,QAAQ,IAAI,aAAa,MAAM;AAElF,IAAa,4BAA4B,UAAU,KAAK;CACtD,MAAM;EACJ,KAAK,QAAQ,2BAA2B;EACxC,MAAM;EACN,MAAM;CACR;CACA,UAAU,CAAC,WAAW,OAAO;CAC7B,OAAO,OAAO,OAAO;EACnB,IAAI,SAAS;EACb,UAAU;EACV,SAAS,OAAO,SAAS,OAAO,OAAO;EACvC,YAAY,OAAO,SAAS,OAAO,MAAM;EACzC,OAAO,OAAO,SAAS,OAAO,OAAO;GAAE,KAAK,OAAO;GAAQ,OAAO,OAAO;EAAI,CAAC,CAAC;CACjF,CAAC;CACD,QAAQ,OAAO;AACjB,CAAC;AAID,IAAa,gBAAgB,UAAU,KAAK;CAC1C,MAAM;EACJ,KAAK,QAAQ,kBAAkB;EAC/B,MAAM;EACN,MAAM;CACR;CACA,UAAU,CAAC,WAAW,OAAO;CAC7B,OAAO,OAAO,OAAO;EACnB,IAAI,SAAS;EACb,YAAY,OAAO;EACnB,MAAM,OAAO,SAAS,OAAO,MAAM;EACnC,SAAS,OAAO,SAAS,IAAI,OAAO;CACtC,CAAC;CACD,QAAQ,OAAO,OAAO;EACpB,IAAI,OAAO;EACX,SAAS,OAAO,MAAM,OAAO,MAAM;EACnC,QAAQ,IAAI;CACd,CAAC;AACH,CAAC;AAED,IAAa,qBAAqB,UAAU,KAAK;CAC/C,MAAM;EACJ,KAAK,QAAQ,oBAAoB;EACjC,MAAM;EACN,MAAM;CACR;CACA,UAAU,CAAC,WAAW,OAAO;CAC7B,OAAO,OAAO,OAAO;EACnB,IAAI,SAAS;;EAEb,SAAS,OAAO,SAAS,OAAO,MAAM,IAAI,OAAO,CAAC;;EAElD,QAAQ,OAAO,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC;;EAEnD,cAAc,OAAO,MAAM,OAAO,QAAQ,IAAI,IAAI,aAAa,YAAY,CAAC;;;;EAI5E,YAAY,OAAO,SAAS,OAAO,OAAO;CAC5C,CAAC;CACD,QAAQ,OAAO,OAAO,EACpB,QAAQ,KAAK,UAAU,KAAK,IAAI,EAClC,CAAC;AACH,CAAC;AAOD,IAAa,aAAa,UAAU,KAAK;CACvC,MAAM;EACJ,KAAK,QAAQ,eAAe;EAC5B,MAAM;EACN,MAAM;CACR;CACA,UAAU,CAAC,WAAW,SAAS,QAAQ,qBAAqB;CAC5D,OAAO,OAAO,OAAO,EACnB,SAAS,IAAI,IAAI,QAAQ,OAAO,EAClC,CAAC;CACD,QAAQ,OAAO;AACjB,CAAC"}

package/dist/lib/chunk-util.mjs

@@ -0,0 +1,142 @@
+import { Instructions, Routine, Trigger } from "@dxos/compute";
+import { Filter, Obj, Query, Ref } from "@dxos/echo";
+import { RunInstructions } from "@dxos/assistant-toolkit";
+import { Cursor } from "@dxos/link";
+//#region src/util/routines-for-object.ts
+/**
+* Reactive query for all routines connected to an object O, via three structural paths:
+*
+* 1. **Trigger path** (two hops): O is referenced by a Trigger (via `input` or `spec.feed`), and that
+*    Trigger is referenced by a Routine's `triggers` array.
+* 2. **Cursor path** (three hops): a sync Trigger doesn't reference its synced target directly — its `binding`
+*    references an external-sync {@link Cursor}, and the Cursor's `spec.target` references O. So O is reached
+*    one hop further out (O ← Cursor ← Trigger ← Routine), keeping the target ref out of the operation input.
+* 3. **Instructions path** (two hops): O is listed in an Instructions' `objects` context array, and those
+*    Instructions are the Routine's action (`spec.instructions`). Both hops traverse `Ref` fields, so they are
+*    fully queryable — no JavaScript parent-symbol traversal needed.
+*
+* ECHO's reverse-ref index is structural — it tracks every `Ref` regardless of schema path, including
+* nested untyped records and union fields — so all variants are covered.
+*/
+var connectedRoutinesQuery = (object) => {
+	const byInput = Query.select(Filter.id(object.id)).referencedBy(Trigger.Trigger);
+	const byFeed = Query.select(Filter.id(object.id)).reference("feed").referencedBy(Trigger.Trigger);
+	const byCursor = Query.select(Filter.id(object.id)).referencedBy(Cursor.Cursor).referencedBy(Trigger.Trigger);
+	const byTrigger = Query.all(byInput, byFeed, byCursor).referencedBy(Routine.Routine, "triggers");
+	const byInstructions = Query.select(Filter.id(object.id)).referencedBy(Instructions.Instructions, "objects").referencedBy(Routine.Routine);
+	return Query.all(byTrigger, byInstructions);
+};
+/**
+* Pure predicate equivalent of {@link connectedRoutinesQuery}, over a pre-queried list of routines.
+* Kept for unit tests (asserting the query and predicate agree) and the deferred quick-association check.
+*/
+var routinesForObject = (object, routines) => routines.filter((routine) => routineReferencesObject(routine, object));
+var routineReferencesObject = (routine, object) => referencesViaTrigger(routine, object) || referencesViaInstructions(routine, object);
+/**
+* Trigger path: a trigger's `input` references O (directly, or via a bound {@link Cursor} whose `spec.target`
+* is O), or a feed trigger is bound to O's feed.
+*/
+var referencesViaTrigger = (routine, object) => {
+	const objectFeedId = getFeedId(object);
+	return routine.triggers.some((ref) => {
+		const trigger = ref.target;
+		if (!Obj.instanceOf(Trigger.Trigger, trigger)) return false;
+		if (trigger.spec?.kind === "feed" && objectFeedId && trigger.spec.feed?.target?.id === objectFeedId) return true;
+		if (trigger.input == null) return false;
+		return referencesId(trigger.input, object.id) || referencesViaCursor(trigger.input, object.id);
+	});
+};
+/** Instructions path: the routine's owned instructions list O in their `objects` context array. */
+var referencesViaInstructions = (routine, object) => Routine.instructionsRef(routine)?.target?.objects?.some((ref) => ref.target?.id === object.id) ?? false;
+/** The feed id a feed-annotated object points at (e.g. `mailbox.feed`), if any. */
+var getFeedId = (object) => {
+	const feedRef = object.feed;
+	return Ref.isRef(feedRef) ? feedRef.target?.id : void 0;
+};
+/** Recursively scan a value for a Cursor ref (e.g. a sync trigger's `binding`) that itself references O. */
+var referencesViaCursor = (value, id) => {
+	if (Ref.isRef(value)) {
+		const cursor = value.target;
+		return Obj.instanceOf(Cursor.Cursor, cursor) && referencesId(cursor.spec, id);
+	}
+	if (Array.isArray(value)) return value.some((entry) => referencesViaCursor(entry, id));
+	if (value && typeof value === "object") return Object.values(value).some((entry) => referencesViaCursor(entry, id));
+	return false;
+};
+/** Recursively scan a value for a Ref whose target is the given object id. */
+var referencesId = (value, id) => {
+	if (Ref.isRef(value)) return value.target?.id === id;
+	if (Array.isArray(value)) return value.some((entry) => referencesId(entry, id));
+	if (value && typeof value === "object") return Object.values(value).some((entry) => referencesId(entry, id));
+	return false;
+};
+//#endregion
+//#region src/util/run-instructions.ts
+/** A ref to the shared RunInstructions operation in the registry (resolved via the registry, not the database). */
+var runInstructionsRef = () => Ref.fromURI(RunInstructions.meta.key);
+/** Whether a trigger's `function` ref targets the registry RunInstructions operation (i.e. an instructions action). */
+var isRunInstructions = (fn) => Ref.isRef(fn) && fn.uri === RunInstructions.meta.key;
+//#endregion
+//#region src/util/wire.ts
+/** Strip a stale `instructions` binding from a trigger input. */
+var withoutInstructions = (input) => {
+	if (!input || !("instructions" in input)) return input;
+	const { instructions: _drop, ...rest } = input;
+	return rest;
+};
+/**
+* Wire the routine's owned triggers to dispatch its current action (`spec`): an instructions action sets each
+* trigger's `runnable` to RunInstructions with the owned instructions bound into `input`; an operation action
+* binds the operation directly and drops any stale instructions binding. Call after the action (`spec`) changes
+* so a trigger never keeps a binding for the previous action.
+*/
+var wireTriggers = (routine) => {
+	const instructions = Routine.instructionsRef(routine);
+	const fn = instructions ? runInstructionsRef() : Routine.runnableRef(routine);
+	for (const ref of routine.triggers) {
+		const trigger = ref.target;
+		if (!trigger) continue;
+		Obj.update(trigger, (trigger) => {
+			trigger.runnable = fn;
+			const base = withoutInstructions(trigger.input);
+			trigger.input = instructions ? {
+				input: {},
+				...base,
+				instructions
+			} : base;
+		});
+	}
+};
+/**
+* Creates a fully-wired in-memory routine graph. `instructions` and `trigger` are optional extras beyond the
+* schema fields: when provided they are parented under the routine and wired together (runnable, trigger
+* runnable, the trigger's instructions input binding, and the `triggers` ref) so that a single `Database.add`
+* cascades the whole graph. `triggers` defaults to `[]` so callers that supply a `trigger` need not provide it.
+*/
+var makeRoutine = ({ instructions, trigger, triggers = [], ...props }) => {
+	const routine = Routine.make({
+		...props,
+		triggers
+	});
+	if (instructions) {
+		Obj.setParent(instructions, routine);
+		Obj.update(routine, (routine) => {
+			routine.spec = {
+				kind: "instructions",
+				instructions: Ref.make(instructions)
+			};
+		});
+	}
+	if (trigger) {
+		Obj.setParent(trigger, routine);
+		Obj.update(routine, (routine) => {
+			routine.triggers.push(Ref.make(trigger));
+		});
+	}
+	if (routine.spec) wireTriggers(routine);
+	return routine;
+};
+//#endregion
+export { connectedRoutinesQuery as a, runInstructionsRef as i, wireTriggers as n, routineReferencesObject as o, isRunInstructions as r, routinesForObject as s, makeRoutine as t };
+
+//# sourceMappingURL=chunk-util.mjs.map

package/dist/lib/chunk-util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-util.mjs","names":[],"sources":["../../src/util/routines-for-object.ts","../../src/util/run-instructions.ts","../../src/util/wire.ts"],"sourcesContent":["//\n// Copyright 2026 DXOS.org\n//\n\nimport { Instructions, Routine, Trigger } from '@dxos/compute';\nimport { Filter, Obj, Query, Ref } from '@dxos/echo';\nimport { Cursor } from '@dxos/link';\n\n/**\n * Reactive query for all routines connected to an object O, via three structural paths:\n *\n * 1. **Trigger path** (two hops): O is referenced by a Trigger (via `input` or `spec.feed`), and that\n *    Trigger is referenced by a Routine's `triggers` array.\n * 2. **Cursor path** (three hops): a sync Trigger doesn't reference its synced target directly — its `binding`\n *    references an external-sync {@link Cursor}, and the Cursor's `spec.target` references O. So O is reached\n *    one hop further out (O ← Cursor ← Trigger ← Routine), keeping the target ref out of the operation input.\n * 3. **Instructions path** (two hops): O is listed in an Instructions' `objects` context array, and those\n *    Instructions are the Routine's action (`spec.instructions`). Both hops traverse `Ref` fields, so they are\n *    fully queryable — no JavaScript parent-symbol traversal needed.\n *\n * ECHO's reverse-ref index is structural — it tracks every `Ref` regardless of schema path, including\n * nested untyped records and union fields — so all variants are covered.\n */\nexport const connectedRoutinesQuery = (object: Obj.Unknown): Query.Query<Routine.Routine> => {\n  // Trigger path: O ← Trigger (any ref path, incl. nested `input`) ← Routine.triggers.\n  const byInput = Query.select(Filter.id(object.id)).referencedBy(Trigger.Trigger);\n  // Feed variant: O's feed ← Trigger.spec.feed ← Routine.triggers.\n  // `.reference('feed')` is empty for objects without a feed prop, so this adds nothing for non-feed objects.\n  const byFeed = Query.select(Filter.id(object.id)).reference('feed').referencedBy(Trigger.Trigger);\n  // Cursor variant: O ← Cursor (spec.target) ← Trigger (input.binding) ← Routine.triggers.\n  const byCursor = Query.select(Filter.id(object.id)).referencedBy(Cursor.Cursor).referencedBy(Trigger.Trigger);\n  const byTrigger = Query.all(byInput, byFeed, byCursor).referencedBy(Routine.Routine, 'triggers');\n\n  // Instructions path: O ← Instructions.objects ← Routine (via `spec.instructions`). The second hop drops the\n  // property key: the instructions ref is nested in the `spec` union, and the reverse-ref index is structural,\n  // so a keyless `referencedBy` matches it (a routine only references its own owned instructions here).\n  const byInstructions = Query.select(Filter.id(object.id))\n    .referencedBy(Instructions.Instructions, 'objects')\n    .referencedBy(Routine.Routine);\n\n  return Query.all(byTrigger, byInstructions);\n};\n\n/**\n * Pure predicate equivalent of {@link connectedRoutinesQuery}, over a pre-queried list of routines.\n * Kept for unit tests (asserting the query and predicate agree) and the deferred quick-association check.\n */\nexport const routinesForObject = (object: Obj.Unknown, routines: Routine.Routine[]): Routine.Routine[] =>\n  routines.filter((routine) => routineReferencesObject(routine, object));\n\nexport const routineReferencesObject = (routine: Routine.Routine, object: Obj.Unknown): boolean =>\n  referencesViaTrigger(routine, object) || referencesViaInstructions(routine, object);\n\n/**\n * Trigger path: a trigger's `input` references O (directly, or via a bound {@link Cursor} whose `spec.target`\n * is O), or a feed trigger is bound to O's feed.\n */\nconst referencesViaTrigger = (routine: Routine.Routine, object: Obj.Unknown): boolean => {\n  const objectFeedId = getFeedId(object);\n  return routine.triggers.some((ref) => {\n    const trigger = ref.target;\n    if (!Obj.instanceOf(Trigger.Trigger, trigger)) {\n      return false;\n    }\n\n    if (trigger.spec?.kind === 'feed' && objectFeedId && trigger.spec.feed?.target?.id === objectFeedId) {\n      return true;\n    }\n\n    if (trigger.input == null) {\n      return false;\n    }\n    return referencesId(trigger.input, object.id) || referencesViaCursor(trigger.input, object.id);\n  });\n};\n\n/** Instructions path: the routine's owned instructions list O in their `objects` context array. */\nconst referencesViaInstructions = (routine: Routine.Routine, object: Obj.Unknown): boolean =>\n  Routine.instructionsRef(routine)?.target?.objects?.some((ref) => ref.target?.id === object.id) ?? false;\n\n/** The feed id a feed-annotated object points at (e.g. `mailbox.feed`), if any. */\nconst getFeedId = (object: Obj.Unknown): string | undefined => {\n  const feedRef = (object as { feed?: Ref.Ref<unknown> }).feed;\n  return Ref.isRef(feedRef) ? feedRef.target?.id : undefined;\n};\n\n/** Recursively scan a value for a Cursor ref (e.g. a sync trigger's `binding`) that itself references O. */\nconst referencesViaCursor = (value: unknown, id: string): boolean => {\n  if (Ref.isRef(value)) {\n    const cursor = value.target;\n    return Obj.instanceOf(Cursor.Cursor, cursor) && referencesId(cursor.spec, id);\n  }\n  if (Array.isArray(value)) {\n    return value.some((entry) => referencesViaCursor(entry, id));\n  }\n  if (value && typeof value === 'object') {\n    return Object.values(value).some((entry) => referencesViaCursor(entry, id));\n  }\n  return false;\n};\n\n/** Recursively scan a value for a Ref whose target is the given object id. */\nconst referencesId = (value: unknown, id: string): boolean => {\n  if (Ref.isRef(value)) {\n    return value.target?.id === id;\n  }\n  if (Array.isArray(value)) {\n    return value.some((entry) => referencesId(entry, id));\n  }\n  if (value && typeof value === 'object') {\n    return Object.values(value).some((entry) => referencesId(entry, id));\n  }\n  return false;\n};\n","//\n// Copyright 2026 DXOS.org\n//\n\nimport { RunInstructions } from '@dxos/assistant-toolkit';\nimport { Ref } from '@dxos/echo';\n\n/** A ref to the shared RunInstructions operation in the registry (resolved via the registry, not the database). */\nexport const runInstructionsRef = () => Ref.fromURI(RunInstructions.meta.key);\n\n/** Whether a trigger's `function` ref targets the registry RunInstructions operation (i.e. an instructions action). */\nexport const isRunInstructions = (fn: unknown): boolean => Ref.isRef(fn) && fn.uri === RunInstructions.meta.key;\n","//\n// Copyright 2026 DXOS.org\n//\n\nimport { type Instructions, Routine, type Trigger } from '@dxos/compute';\nimport { Obj, Ref } from '@dxos/echo';\n\nimport { runInstructionsRef } from './run-instructions';\n\n/** Strip a stale `instructions` binding from a trigger input. */\nconst withoutInstructions = (input: Record<string, unknown> | undefined): Record<string, unknown> | undefined => {\n  if (!input || !('instructions' in input)) {\n    return input;\n  }\n  const { instructions: _drop, ...rest } = input;\n  return rest;\n};\n\n/**\n * Wire the routine's owned triggers to dispatch its current action (`spec`): an instructions action sets each\n * trigger's `runnable` to RunInstructions with the owned instructions bound into `input`; an operation action\n * binds the operation directly and drops any stale instructions binding. Call after the action (`spec`) changes\n * so a trigger never keeps a binding for the previous action.\n */\nexport const wireTriggers = (routine: Routine.Routine): void => {\n  const instructions = Routine.instructionsRef(routine);\n  const fn = instructions ? runInstructionsRef() : Routine.runnableRef(routine);\n  for (const ref of routine.triggers) {\n    const trigger = ref.target;\n    if (!trigger) {\n      continue;\n    }\n    Obj.update(trigger, (trigger) => {\n      trigger.runnable = fn;\n      const base = withoutInstructions(trigger.input);\n      trigger.input = instructions ? { input: {}, ...base, instructions } : base;\n    });\n  }\n};\n\n/**\n * Creates a fully-wired in-memory routine graph. `instructions` and `trigger` are optional extras beyond the\n * schema fields: when provided they are parented under the routine and wired together (runnable, trigger\n * runnable, the trigger's instructions input binding, and the `triggers` ref) so that a single `Database.add`\n * cascades the whole graph. `triggers` defaults to `[]` so callers that supply a `trigger` need not provide it.\n */\nexport const makeRoutine = ({\n  instructions,\n  trigger,\n  triggers = [],\n  ...props\n}: Omit<Obj.MakeProps<typeof Routine.Routine>, 'triggers'> & {\n  triggers?: ReadonlyArray<Ref.Ref<Trigger.Trigger>>;\n  instructions?: Instructions.Instructions;\n  trigger?: Trigger.Trigger;\n}): Routine.Routine => {\n  const routine = Routine.make({ ...props, triggers });\n  if (instructions) {\n    Obj.setParent(instructions, routine);\n    Obj.update(routine, (routine) => {\n      routine.spec = { kind: 'instructions', instructions: Ref.make(instructions) };\n    });\n  }\n  if (trigger) {\n    Obj.setParent(trigger, routine);\n    Obj.update(routine, (routine) => {\n      routine.triggers.push(Ref.make(trigger));\n    });\n  }\n  // Wire every attached trigger (singular or `triggers`) from the action; preserves template-provided\n  // input. Gated on `spec`: with no action yet, wiring would null out pre-set trigger runnables.\n  if (routine.spec) {\n    wireTriggers(routine);\n  }\n  return routine;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,0BAA0B,WAAsD;CAE3F,MAAM,UAAU,MAAM,OAAO,OAAO,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,aAAa,QAAQ,OAAO;CAG/E,MAAM,SAAS,MAAM,OAAO,OAAO,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,UAAU,MAAM,CAAC,CAAC,aAAa,QAAQ,OAAO;CAEhG,MAAM,WAAW,MAAM,OAAO,OAAO,GAAG,OAAO,EAAE,CAAC,CAAC,CAAC,aAAa,OAAO,MAAM,CAAC,CAAC,aAAa,QAAQ,OAAO;CAC5G,MAAM,YAAY,MAAM,IAAI,SAAS,QAAQ,QAAQ,CAAC,CAAC,aAAa,QAAQ,SAAS,UAAU;CAK/F,MAAM,iBAAiB,MAAM,OAAO,OAAO,GAAG,OAAO,EAAE,CAAC,CAAA,CACrD,aAAa,aAAa,cAAc,SAAS,CAAA,CACjD,aAAa,QAAQ,OAAO;CAE/B,OAAO,MAAM,IAAI,WAAW,cAAc;AAC5C;;;;;AAMA,IAAa,qBAAqB,QAAqB,aACrD,SAAS,QAAQ,YAAY,wBAAwB,SAAS,MAAM,CAAC;AAEvE,IAAa,2BAA2B,SAA0B,WAChE,qBAAqB,SAAS,MAAM,KAAK,0BAA0B,SAAS,MAAM;;;;;AAMpF,IAAM,wBAAwB,SAA0B,WAAiC;CACvF,MAAM,eAAe,UAAU,MAAM;CACrC,OAAO,QAAQ,SAAS,MAAM,QAAQ;EACpC,MAAM,UAAU,IAAI;EACpB,IAAI,CAAC,IAAI,WAAW,QAAQ,SAAS,OAAO,GAC1C,OAAO;EAGT,IAAI,QAAQ,MAAM,SAAS,UAAU,gBAAgB,QAAQ,KAAK,MAAM,QAAQ,OAAO,cACrF,OAAO;EAGT,IAAI,QAAQ,SAAS,MACnB,OAAO;EAET,OAAO,aAAa,QAAQ,OAAO,OAAO,EAAE,KAAK,oBAAoB,QAAQ,OAAO,OAAO,EAAE;CAC/F,CAAC;AACH;;AAGA,IAAM,6BAA6B,SAA0B,WAC3D,QAAQ,gBAAgB,OAAO,CAAC,EAAE,QAAQ,SAAS,MAAM,QAAQ,IAAI,QAAQ,OAAO,OAAO,EAAE,KAAK;;AAGpG,IAAM,aAAa,WAA4C;CAC7D,MAAM,UAAW,OAAuC;CACxD,OAAO,IAAI,MAAM,OAAO,IAAI,QAAQ,QAAQ,KAAK,KAAA;AACnD;;AAGA,IAAM,uBAAuB,OAAgB,OAAwB;CACnE,IAAI,IAAI,MAAM,KAAK,GAAG;EACpB,MAAM,SAAS,MAAM;EACrB,OAAO,IAAI,WAAW,OAAO,QAAQ,MAAM,KAAK,aAAa,OAAO,MAAM,EAAE;CAC9E;CACA,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,UAAU,oBAAoB,OAAO,EAAE,CAAC;CAE7D,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,UAAU,oBAAoB,OAAO,EAAE,CAAC;CAE5E,OAAO;AACT;;AAGA,IAAM,gBAAgB,OAAgB,OAAwB;CAC5D,IAAI,IAAI,MAAM,KAAK,GACjB,OAAO,MAAM,QAAQ,OAAO;CAE9B,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,MAAM,UAAU,aAAa,OAAO,EAAE,CAAC;CAEtD,IAAI,SAAS,OAAO,UAAU,UAC5B,OAAO,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,UAAU,aAAa,OAAO,EAAE,CAAC;CAErE,OAAO;AACT;;;;ACzGA,IAAa,2BAA2B,IAAI,QAAQ,gBAAgB,KAAK,GAAG;;AAG5E,IAAa,qBAAqB,OAAyB,IAAI,MAAM,EAAE,KAAK,GAAG,QAAQ,gBAAgB,KAAK;;;;ACD5G,IAAM,uBAAuB,UAAoF;CAC/G,IAAI,CAAC,SAAS,EAAE,kBAAkB,QAChC,OAAO;CAET,MAAM,EAAE,cAAc,OAAO,GAAG,SAAS;CACzC,OAAO;AACT;;;;;;;AAQA,IAAa,gBAAgB,YAAmC;CAC9D,MAAM,eAAe,QAAQ,gBAAgB,OAAO;CACpD,MAAM,KAAK,eAAe,mBAAmB,IAAI,QAAQ,YAAY,OAAO;CAC5E,KAAK,MAAM,OAAO,QAAQ,UAAU;EAClC,MAAM,UAAU,IAAI;EACpB,IAAI,CAAC,SACH;EAEF,IAAI,OAAO,UAAU,YAAY;GAC/B,QAAQ,WAAW;GACnB,MAAM,OAAO,oBAAoB,QAAQ,KAAK;GAC9C,QAAQ,QAAQ,eAAe;IAAE,OAAO,CAAC;IAAG,GAAG;IAAM;GAAa,IAAI;EACxE,CAAC;CACH;AACF;;;;;;;AAQA,IAAa,eAAe,EAC1B,cACA,SACA,WAAW,CAAC,GACZ,GAAG,YAKkB;CACrB,MAAM,UAAU,QAAQ,KAAK;EAAE,GAAG;EAAO;CAAS,CAAC;CACnD,IAAI,cAAc;EAChB,IAAI,UAAU,cAAc,OAAO;EACnC,IAAI,OAAO,UAAU,YAAY;GAC/B,QAAQ,OAAO;IAAE,MAAM;IAAgB,cAAc,IAAI,KAAK,YAAY;GAAE;EAC9E,CAAC;CACH;CACA,IAAI,SAAS;EACX,IAAI,UAAU,SAAS,OAAO;EAC9B,IAAI,OAAO,UAAU,YAAY;GAC/B,QAAQ,SAAS,KAAK,IAAI,KAAK,OAAO,CAAC;EACzC,CAAC;CACH;CAGA,IAAI,QAAQ,MACV,aAAa,OAAO;CAEtB,OAAO;AACT"}