@agimon-ai/po-loop 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,668 @@
+import { t as DOOM_LOOP_LAUNCHERS_SERVICE } from "../loopLaunchers-CskBMAKF.mjs";
+import { composeServerProviderOverrides, defineServerPlugin, defineTool, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineRoot, defineRoutedContribution, defineTool as defineTool$1 } from "@agimon-ai/po-core/extensionFile";
+import { defineMinorMode, serverMinorModes } from "@agimon-ai/po-minor-mode";
+import { Cron } from "croner";
+import { Type } from "typebox";
+import { Check } from "typebox/value";
+//#region src/constants/loop.ts
+const LIST_COMMAND_NAME = "loops";
+//#endregion
+//#region src/constants/piLoop.ts
+const PACKAGE_SOURCE = "@agimon-ai/po-loop";
+const MODE_STATUS_ID = "loop";
+//#endregion
+//#region src/schemas/loopTools.ts
+const LoopListSchema = Type.Object({}, { additionalProperties: false });
+const LoopStartSchema = Type.Object({
+	launcherId: Type.String({
+		minLength: 1,
+		maxLength: 256
+	}),
+	instanceId: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 256
+	})),
+	input: Type.Record(Type.String(), Type.Unknown())
+}, { additionalProperties: false });
+const LoopStopSchema = Type.Object({
+	instanceId: Type.String({
+		minLength: 1,
+		maxLength: 256
+	}),
+	reason: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 512
+	}))
+}, { additionalProperties: false });
+const IntervalLoopSchema = Type.Object({
+	prompt: Type.String({
+		minLength: 1,
+		maxLength: 32768
+	}),
+	intervalSeconds: Type.Integer({
+		minimum: 30,
+		maximum: 3600
+	})
+}, { additionalProperties: false });
+const CronLoopSchema = Type.Object({
+	prompt: Type.String({
+		minLength: 1,
+		maxLength: 32768
+	}),
+	cron: Type.String({
+		minLength: 1,
+		maxLength: 256
+	}),
+	timezone: Type.Optional(Type.String({
+		minLength: 1,
+		maxLength: 128
+	}))
+}, { additionalProperties: false });
+function parseIntervalLoop(input) {
+	if (!Check(IntervalLoopSchema, input) || !input.prompt.trim()) throw new Error("Provide a non-empty prompt and an integer intervalSeconds between 30 and 3600.");
+	return {
+		...input,
+		prompt: input.prompt.trim()
+	};
+}
+function parseCronLoop(input) {
+	if (!Check(CronLoopSchema, input) || !input.prompt.trim() || input.cron.trim().split(/\s+/u).length !== 5) throw new Error("Provide a non-empty prompt and a five-field cron expression, with an optional IANA timezone.");
+	const timezone = input.timezone ?? "UTC";
+	new Intl.DateTimeFormat("en", { timeZone: timezone }).format();
+	return {
+		...input,
+		prompt: input.prompt.trim(),
+		cron: input.cron.trim(),
+		timezone
+	};
+}
+//#endregion
+//#region src/types/loopView.ts
+/** The browser-only status that carries active Loop instances into the activity dock. */
+const LOOP_VIEW_STATUS_KEY = "doom-loop-instances";
+new RegExp(String.raw`\u001b\[[0-9;]*m`, "gu");
+/** Projects runtime snapshots into the JSON status consumed by the web plugin. */
+function formatLoopStatusView(instances) {
+	if (instances.length === 0) return "";
+	return JSON.stringify(instances.map((instance) => ({
+		instanceId: instance.instanceId,
+		label: instance.label ?? instance.launcherLabel,
+		detail: instance.detail ?? instance.instanceId,
+		state: instance.state
+	})));
+}
+//#endregion
+//#region src/services/loopLaunchers/index.ts
+const MAX_ID_LENGTH = 256;
+const MAX_GENERATION_LENGTH = 256;
+const LAUNCHER_ID_LABEL = "loop launcher id";
+const INSTANCE_ID_LABEL = "loop instance id";
+function validId(value, label) {
+	if (typeof value !== "string") throw new TypeError(`Invalid ${label}.`);
+	const normalized = value.trim();
+	let hasControl = false;
+	for (const character of normalized) {
+		const code = character.codePointAt(0);
+		if (code !== void 0 && (code <= 31 || code === 127)) {
+			hasControl = true;
+			break;
+		}
+	}
+	if (!normalized || normalized.length > MAX_ID_LENGTH || hasControl) throw new Error(`Invalid ${label}.`);
+	return normalized;
+}
+function snapshot(entry) {
+	return {
+		instanceId: entry.instanceId,
+		launcherId: entry.launcher.definition.id,
+		launcherLabel: entry.launcher.definition.label,
+		...entry.handle?.label ? { label: entry.handle.label } : {},
+		...entry.handle?.detail ? { detail: entry.handle.detail } : {},
+		state: entry.state,
+		...entry.startedAt ? { startedAt: entry.startedAt } : {}
+	};
+}
+/** Creates the provider-owned launcher registry for one active Doom session. */
+function createDoomLoopLaunchersService({ generation, createInstanceId, timestamp }) {
+	if (!generation || generation.length > MAX_GENERATION_LENGTH) throw new TypeError("Doom loop launchers require a valid generation.");
+	const launchers = /* @__PURE__ */ new Map();
+	const instances = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let registrationSequence = 0;
+	let disposed = false;
+	const ensureActive = () => {
+		if (disposed) throw new Error("The Doom loop-launchers service is disposed.");
+	};
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	const stopEntry = async (entry, reason) => {
+		if (instances.get(entry.instanceId) !== entry) return;
+		entry.state = "stopping";
+		entry.abortController.abort(reason);
+		notify();
+		try {
+			await entry.handle?.stop(reason);
+		} finally {
+			if (instances.get(entry.instanceId) === entry) instances.delete(entry.instanceId);
+			notify();
+		}
+	};
+	return Object.freeze({
+		generation,
+		register(definition) {
+			ensureActive();
+			const id = validId(definition.id, LAUNCHER_ID_LABEL);
+			if (launchers.has(id)) throw new Error(`Loop launcher '${id}' is already registered.`);
+			const token = Symbol(id);
+			const entry = {
+				token,
+				definition: {
+					...definition,
+					id
+				}
+			};
+			launchers.set(id, entry);
+			registrationSequence += 1;
+			notify();
+			let registrationDisposed = false;
+			return Object.freeze({
+				id,
+				generation: `${generation}:launcher:${registrationSequence}`,
+				async dispose(reason = "Loop launcher disposed.") {
+					if (registrationDisposed) return;
+					registrationDisposed = true;
+					if (launchers.get(id)?.token !== token) return;
+					launchers.delete(id);
+					const owned = [...instances.values()].filter((instance) => instance.launcher.token === token);
+					await Promise.allSettled(owned.map((instance) => stopEntry(instance, reason)));
+					notify();
+				}
+			});
+		},
+		listLaunchers() {
+			ensureActive();
+			return [...launchers.values()].map(({ definition }) => ({
+				id: definition.id,
+				source: definition.source,
+				label: definition.label,
+				...definition.description ? { description: definition.description } : {},
+				...definition.inputSchema ? { inputSchema: definition.inputSchema } : {}
+			})).sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id));
+		},
+		listInstances() {
+			ensureActive();
+			return [...instances.values()].map(snapshot).sort((left, right) => left.instanceId.localeCompare(right.instanceId));
+		},
+		subscribe(listener) {
+			ensureActive();
+			listeners.add(listener);
+			let subscribed = true;
+			return () => {
+				if (!subscribed) return;
+				subscribed = false;
+				listeners.delete(listener);
+			};
+		},
+		async launch(launcherId, options) {
+			ensureActive();
+			options?.signal?.throwIfAborted();
+			const normalizedLauncherId = validId(launcherId, LAUNCHER_ID_LABEL);
+			const launcher = launchers.get(normalizedLauncherId);
+			if (!launcher) throw new Error(`Loop launcher '${normalizedLauncherId}' is unavailable.`);
+			const instanceId = validId(options?.instanceId ?? createInstanceId(), INSTANCE_ID_LABEL);
+			if (instances.has(instanceId)) throw new Error(`Loop instance '${instanceId}' already exists.`);
+			const entry = {
+				instanceId,
+				launcher,
+				abortController: new AbortController(),
+				state: "starting"
+			};
+			const abortSetup = () => entry.abortController.abort(options?.signal?.reason);
+			options?.signal?.addEventListener("abort", abortSetup, { once: true });
+			instances.set(instanceId, entry);
+			notify();
+			try {
+				if (options?.interactive === false && !launcher.definition.inputSchema) throw new Error(`Loop launcher '${normalizedLauncherId}' requires manual setup in Activity.`);
+				const handle = await launcher.definition.launch({
+					instanceId,
+					signal: entry.abortController.signal,
+					...options?.input === void 0 ? {} : { input: options.input },
+					...options?.interactive === void 0 ? {} : { interactive: options.interactive }
+				});
+				const active = !disposed && instances.get(instanceId) === entry && !entry.abortController.signal.aborted;
+				if (!handle) {
+					if (instances.get(instanceId) === entry) instances.delete(instanceId);
+					notify();
+					return;
+				}
+				if (!active || handle.instanceId !== instanceId) {
+					await handle.stop(active ? "Loop launcher returned a mismatched instance id." : "Loop launch was cancelled.");
+					if (instances.get(instanceId) === entry) instances.delete(instanceId);
+					notify();
+					if (active) throw new Error(`Loop launcher '${normalizedLauncherId}' returned a mismatched instance id.`);
+					return;
+				}
+				entry.handle = handle;
+				entry.state = "running";
+				entry.startedAt = timestamp();
+				notify();
+				return snapshot(entry);
+			} catch (error) {
+				const cancelled = entry.abortController.signal.aborted || disposed;
+				if (instances.get(instanceId) === entry) instances.delete(instanceId);
+				notify();
+				if (cancelled) return void 0;
+				throw error;
+			} finally {
+				options?.signal?.removeEventListener("abort", abortSetup);
+			}
+		},
+		async stop(instanceId, reason) {
+			ensureActive();
+			const entry = instances.get(validId(instanceId, INSTANCE_ID_LABEL));
+			if (!entry) return false;
+			await stopEntry(entry, reason);
+			return true;
+		},
+		async stopAll(reason) {
+			if (disposed && instances.size === 0) return;
+			await Promise.allSettled([...instances.values()].map((entry) => stopEntry(entry, reason)));
+		},
+		async dispose(reason = "Doom loop-launchers service disposed.") {
+			if (disposed) return;
+			disposed = true;
+			launchers.clear();
+			await Promise.allSettled([...instances.values()].map((entry) => stopEntry(entry, reason)));
+			listeners.clear();
+		}
+	});
+}
+//#endregion
+//#region src/services/loopTools/index.ts
+function result(details) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(details, null, 2)
+		}],
+		details
+	};
+}
+function createLoopTools(launchers, assertEnabled) {
+	return [
+		defineTool({
+			name: "loop_list",
+			label: "List loops",
+			description: "List active session loops and available launcher types with their configuration schemas.",
+			parameters: LoopListSchema,
+			async execute(input, { signal }) {
+				assertEnabled();
+				signal?.throwIfAborted();
+				if (!Check(LoopListSchema, input)) throw new Error("loop_list takes no arguments.");
+				const service = launchers();
+				return result({
+					launchers: service.listLaunchers(),
+					instances: service.listInstances()
+				});
+			}
+		}),
+		defineTool({
+			name: "loop_start",
+			label: "Start loop",
+			description: "Start a session-scoped loop without operator dialogs. Read loop_list for launcher IDs and input schemas. Loops stop when the session shuts down.",
+			parameters: LoopStartSchema,
+			executionMode: "serial",
+			async execute(input, { signal }) {
+				assertEnabled();
+				signal?.throwIfAborted();
+				if (!Check(LoopStartSchema, input)) throw new Error("Provide launcherId, input, and optionally instanceId.");
+				return result(await launchers().launch(input.launcherId, {
+					...input,
+					interactive: false,
+					signal
+				}) ?? { cancelled: true });
+			}
+		}),
+		defineTool({
+			name: "loop_stop",
+			label: "Stop loop",
+			description: "Stop one loop instance owned by the current session. Does not disable Loop mode or stop other loops.",
+			parameters: LoopStopSchema,
+			executionMode: "serial",
+			async execute(input, { signal }) {
+				assertEnabled();
+				signal?.throwIfAborted();
+				if (!Check(LoopStopSchema, input)) throw new Error("Provide instanceId and an optional reason.");
+				return result({ stopped: await launchers().stop(input.instanceId, input.reason ?? "Stopped by the agent.") });
+			}
+		})
+	];
+}
+//#endregion
+//#region src/services/serverRuntime/index.ts
+/** Loops are set by the agent, so a launch always carries its configuration. */
+function prepareLoop(request, cron) {
+	if (request.input === void 0) throw new Error("Loop configuration is required. Ask the agent to set the loop.");
+	return cron ? parseCronLoop(request.input) : parseIntervalLoop(request.input);
+}
+function createSessionState(host) {
+	const launchers = createDoomLoopLaunchersService({
+		generation: `${host.context.sessionId}:loop-launchers`,
+		createInstanceId: () => crypto.randomUUID(),
+		timestamp: () => (/* @__PURE__ */ new Date()).toISOString()
+	});
+	let disposed = false;
+	const modeSelected = () => !disposed && (host.context.selection.state?.["minor-mode"] ?? []).includes("loop");
+	const publishView = () => host.context.client.setStatus(LOOP_VIEW_STATUS_KEY, formatLoopStatusView(launchers.listInstances()));
+	const modeOwner = defineMinorMode({
+		descriptor: {
+			source: PACKAGE_SOURCE,
+			id: MODE_STATUS_ID,
+			label: "Loop",
+			description: "Give the agent tools to create, inspect, and stop session loops.",
+			order: 60,
+			actions: [{
+				id: "activate",
+				label: "Activate",
+				description: "Expose loop tools to the agent.",
+				contexts: ["headless"],
+				parameters: []
+			}, {
+				id: "deactivate",
+				label: "Deactivate",
+				description: "Hide agent loop tools. Existing loops and manual controls remain available.",
+				contexts: ["headless"],
+				parameters: []
+			}]
+		},
+		state: () => ({
+			activation: modeSelected() ? "active" : "inactive",
+			condition: "ready",
+			...modeSelected() ? {
+				detail: `${launchers.listInstances().length} loops`,
+				color: "accent"
+			} : {},
+			actions: [{
+				id: "activate",
+				enabled: !modeSelected(),
+				...modeSelected() ? { disabledReason: "Loop mode is already active." } : {}
+			}, {
+				id: "deactivate",
+				enabled: modeSelected(),
+				...modeSelected() ? {} : { disabledReason: "Loop mode is not active." }
+			}]
+		}),
+		async handleAction(_runtime, actionId, _arguments, { signal }) {
+			signal.throwIfAborted();
+			if (actionId !== "activate" && actionId !== "deactivate") throw new Error(`Unknown loop mode action: ${actionId}`);
+			const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== MODE_STATUS_ID);
+			await host.changeSelection({
+				axis: "state",
+				key: "minor-mode",
+				values: actionId === "activate" ? [...modes, MODE_STATUS_ID] : modes
+			});
+			modeOwner.publish();
+			return { message: actionId === "activate" ? "Loop tools activated." : "Loop tools deactivated. Existing loops are unchanged." };
+		}
+	}).createOwner(void 0);
+	const publish = () => {
+		if (disposed) return;
+		modeOwner.publish();
+		publishView();
+	};
+	const unsubscribe = launchers.subscribe(publish);
+	let submitting = false;
+	const pending = /* @__PURE__ */ new Set();
+	for (const cron of [false, true]) launchers.register({
+		id: cron ? "po.cron" : "po.default",
+		source: PACKAGE_SOURCE,
+		label: cron ? "Cron loop" : "Default loop",
+		description: cron ? "Run a prompt on a five-field cron schedule." : "Run a prompt in this session on an interval.",
+		inputSchema: { ...cron ? CronLoopSchema : IntervalLoopSchema },
+		async launch(request) {
+			const execution = host.context;
+			const prepared = prepareLoop(request, cron);
+			if (!prepared || request.signal.aborted) return void 0;
+			let stopped = false;
+			const tick = async (due = true) => {
+				if (disposed || stopped || request.signal.aborted) return;
+				if (due) pending.add(replay);
+				if (submitting || !pending.has(replay)) return;
+				submitting = true;
+				try {
+					const activity = await execution.session.activity();
+					if (disposed || stopped || request.signal.aborted || !activity.isIdle || activity.hasPendingMessages) return;
+					pending.delete(replay);
+					if (!execution.session.admitPrompt) throw new Error("Loop prompt admission is unavailable.");
+					await execution.session.admitPrompt(prepared.prompt);
+				} catch (error) {
+					await execution.client.notify({
+						body: `Loop pass failed: ${error instanceof Error ? error.message : String(error)}`,
+						level: "warning"
+					});
+				} finally {
+					submitting = false;
+				}
+			};
+			const replay = () => tick(false);
+			let stopTimer;
+			let detail;
+			if ("cron" in prepared) {
+				const job = new Cron(prepared.cron, {
+					timezone: prepared.timezone,
+					unref: true
+				}, () => tick());
+				if (job.nextRun() === null) {
+					job.stop();
+					throw new Error("Cron expression has no future run.");
+				}
+				stopTimer = () => {
+					job.stop();
+				};
+				detail = `${prepared.cron} (${prepared.timezone})`;
+			} else {
+				const timer = setInterval(() => {
+					tick();
+				}, prepared.intervalSeconds * 1e3);
+				timer.unref?.();
+				stopTimer = () => clearInterval(timer);
+				detail = `every ${prepared.intervalSeconds}s`;
+				tick();
+			}
+			return {
+				instanceId: request.instanceId,
+				label: cron ? "Cron loop" : "Default loop",
+				detail,
+				stop() {
+					stopped = true;
+					pending.delete(replay);
+					stopTimer();
+				}
+			};
+		}
+	});
+	return {
+		loopTools: createLoopTools(() => launchers, () => {
+			if (!modeSelected()) throw new Error("Enable Loop minor mode before using agent loop tools.");
+		}).map((tool) => ({
+			...tool,
+			when: {
+				state: { "minor-mode": MODE_STATUS_ID },
+				attribution: {
+					kind: "minor",
+					mode: MODE_STATUS_ID
+				}
+			}
+		})),
+		services: [(context) => {
+			context.plugin((provider) => {
+				provider.provide(DOOM_LOOP_LAUNCHERS_SERVICE, launchers);
+			});
+			context.effect(() => host.subscribeSelection(publish));
+		}, serverMinorModes([modeOwner])],
+		resources: [{
+			when: {
+				state: { "minor-mode": MODE_STATUS_ID },
+				attribution: {
+					kind: "minor",
+					mode: MODE_STATUS_ID
+				}
+			},
+			name: "po-use-loop",
+			kind: "skill",
+			read: () => readPackageResource(import.meta.url, "src/prompts/po-use-loop/SKILL.md")
+		}],
+		activities: [{
+			name: "po-loop",
+			async start() {
+				publish();
+				return async () => {
+					await launchers.stopAll("Session loop activity stopped.");
+					publish();
+				};
+			}
+		}],
+		commands: [{
+			name: LIST_COMMAND_NAME,
+			description: "List or stop session loops. Usage: /loops [stop instanceId].",
+			async execute(args, execution) {
+				const parts = args.trim().split(/\s+/u);
+				if (parts[0] === "stop" && parts.length === 2) {
+					const stopped = await launchers.stop(parts[1], "Stopped manually.");
+					await execution.client.notify({
+						body: stopped ? "Loop stopped." : "Loop instance was not active.",
+						level: "info"
+					});
+					return;
+				}
+				if (args.trim()) throw new Error("Usage: /loops [stop instanceId]");
+				const instances = launchers.listInstances();
+				await execution.client.notify({
+					body: instances.length === 0 ? "No loops are active." : JSON.stringify(instances, null, 2),
+					level: "info"
+				});
+			}
+		}],
+		hooks: [
+			{
+				event: "agent_settled",
+				async handle() {
+					if (!disposed) await pending.values().next().value?.();
+				}
+			},
+			{
+				event: "session_start",
+				async handle() {
+					publish();
+				}
+			},
+			{
+				event: "session_shutdown",
+				async handle() {
+					await launchers.stopAll("Headless session shutdown.");
+				}
+			}
+		],
+		onStart: publish,
+		async onDispose() {
+			if (disposed) return;
+			disposed = true;
+			pending.clear();
+			unsubscribe();
+			await launchers.dispose("Headless loop facet disposed.");
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/runtime.server.ts
+var runtime_server_default = (({ agent }) => agent ? createSessionState(agent) : { loopTools: [] });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot((context) => {
+	const value = runtime_server_default(context);
+	return {
+		value,
+		services: value.services,
+		activities: value.activities,
+		onStart: value.onStart,
+		onStop: value.onStop,
+		onDispose: value.onDispose
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/loops.server.ts
+var loops_server_default = defineRoutedContribution((context) => context.root.commands?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineRoutedContribution((context) => context.root.hooks?.find((hook) => hook.event === "agent_settled"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineRoutedContribution((context) => context.root.hooks?.find((hook) => hook.event === "session_shutdown"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineRoutedContribution((context) => context.root.hooks?.find((hook) => hook.event === "session_start"), { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-use-loop.server.ts
+var po_use_loop_server_default = defineRoutedContribution((context) => context.root.resources?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-list.server.ts
+var loop_list_server_default = defineTool$1((context) => context.root.loopTools[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-start.server.ts
+var loop_start_server_default = defineTool$1((context) => context.root.loopTools[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/loop-stop.server.ts
+var loop_stop_server_default = defineTool$1((context) => context.root.loopTools[2]);
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-loop",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get commands() {
+				return defined([via({ name: "loops" }, at(loops_server_default, contextSession))]);
+			},
+			get hooks() {
+				return defined([
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession))
+				]);
+			},
+			get resources() {
+				return defined([at(po_use_loop_server_default, contextSession)]);
+			},
+			get tools() {
+				return [
+					via({ name: "loop_list" }, at(loop_list_server_default, contextSession)),
+					via({ name: "loop_start" }, at(loop_start_server_default, contextSession)),
+					via({ name: "loop_stop" }, at(loop_stop_server_default, contextSession))
+				];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map