@agimon-ai/doompi-author 0.0.1-alpha.2 → 0.0.1-alpha.21

package/dist/extensions/server.mjs

@@ -0,0 +1,652 @@
+import { a as authorBridgeMethod } from "../authorFacade-B9-Re3Ga.mjs";
+import { a as createAuthorTools, d as parseUseAuthorToolInput, i as AUTHOR_TOOL_WHEN, n as authorMinorMode, p as AUTHOR_GUIDANCE, r as createAuthorCatalog, t as createAuthorCommand } from "../authorCommand-B90ghX5J.mjs";
+import { b as createAuthorBridgeState, n as preflightStructuredDocument, r as serializeStructuredDocument, t as parseStructuredDocument, y as AuthorBridgeError } from "../structuredDocuments-CzMYD0Bq.mjs";
+import { serverMinorModes } from "@agimon-ai/doompi-minor-mode";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { composeRootHooks, defineChannel, defineCommand, defineHook, defineMethod, defineResource, defineRoot, defineRoute, defineTool } from "@agimon-ai/doompi-core/extensionFile";
+import { defineServerMethod, defineServerPlugin, readPackageResource } from "@agimon-ai/doompi-core/serverFacet";
+import { Hono } from "hono";
+import fs from "node:fs/promises";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/doompi-core/web";
+//#region src/services/structuredDocuments/document.ts
+const AUTHOR_DOCUMENT_MAX_BYTES = 26214400;
+async function readDocument(cwd, requestedPath) {
+	if (typeof requestedPath !== "string" || requestedPath.length === 0 || requestedPath.includes("\0") || path.isAbsolute(requestedPath)) throw new Error("A relative document path is required.");
+	const root = await fs.realpath(cwd);
+	const candidate = path.resolve(root, requestedPath);
+	if (candidate !== root && !candidate.startsWith(`${root}${path.sep}`)) throw new Error("Document path is outside the working directory.");
+	const realCandidate = await fs.realpath(candidate);
+	if (realCandidate !== root && !realCandidate.startsWith(`${root}${path.sep}`)) throw new Error("Document path is outside the working directory.");
+	if ((await fs.stat(realCandidate)).size > 26214400) throw new Error(`Document exceeds the ${AUTHOR_DOCUMENT_MAX_BYTES} byte preview limit.`);
+	return await fs.readFile(realCandidate);
+}
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/author/`, so the mount is
+* stated once, by the folder that creates it. The browser used to restate it:
+* `authorStateUrl` built one URL from `API_BASE_PATH` and the document helper
+* two files away spelled `author` out again as a literal, so the two could
+* disagree and nothing would say so.
+*
+* The order below is the order the three Hono apps register in: `/state` in
+* `authorApi`, the eight bridge routes in `authorBridgeApi`, the three document
+* routes in `authorDocumentApi`. A reviewer can read the two side by side.
+*
+* Response types are named only where a caller reads the body. The bridge
+* routes are called by the hub's author channel over `requestSessionApi`, which
+* has its own message vocabulary and never sees this client.
+*/
+var apiRoutes_default = defineApiRoutes({
+	state: {
+		method: "GET",
+		path: "/state",
+		response: apiResponse()
+	},
+	bridgeRegister: {
+		method: "POST",
+		path: "/bridge/register"
+	},
+	bridgeCatalog: {
+		method: "POST",
+		path: "/bridge/catalog"
+	},
+	/** Long-polls for the next capability request, so it settles when one arrives. */
+	bridgeNext: {
+		method: "POST",
+		path: "/bridge/next"
+	},
+	bridgeResult: {
+		method: "POST",
+		path: "/bridge/result"
+	},
+	bridgeCancelled: {
+		method: "POST",
+		path: "/bridge/cancelled"
+	},
+	bridgeDisconnect: {
+		method: "POST",
+		path: "/bridge/disconnect"
+	},
+	bridgeDescribe: {
+		method: "GET",
+		path: "/bridge/describe"
+	},
+	bridgeInvoke: {
+		method: "POST",
+		path: "/bridge/invoke"
+	},
+	/**
+	* Parses one structured document.
+	*
+	* Answers a byte-length summary instead when the request names no format,
+	* which is the agent-side tool path; the page always names one.
+	*/
+	documentsOpen: {
+		method: "POST",
+		path: "/documents/open",
+		query: ["session"],
+		response: apiResponse()
+	},
+	documentsPreflight: {
+		method: "POST",
+		path: "/documents/preflight",
+		query: ["session"],
+		response: apiResponse()
+	},
+	documentsSerialize: {
+		method: "POST",
+		path: "/documents/serialize",
+		query: ["session"],
+		response: apiResponse()
+	},
+	/**
+	* The host's own bytes route, not this package's.
+	*
+	* `host: true` hangs it off the session root rather than under `/plugins`,
+	* which is how the cockpit already serves it. Author reads a document's
+	* bytes and its digest through it, and writes the edited bytes back to the
+	* same path, so both stay raw transfers rather than calls: the body is the
+	* file and the digest travels in a header.
+	*/
+	file: {
+		method: "GET",
+		path: "/file",
+		query: ["path"],
+		host: true
+	}
+});
+//#endregion
+//#region src/types/authorApi.ts
+/**
+* The wire vocabulary this package's API shares with whatever calls it.
+*
+* Paths live in `./apiRoutes`, which the Hono apps register from and the
+* generated client addresses, so neither half can move alone. What stays here
+* is the mount segment the server registers under and the shape the state
+* route answers with.
+*/
+/** Where a host mounts this package's API; the segment after /api/plugins/. */
+const API_BASE_PATH = "author";
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/author/_lib/authorBridgeApi.ts
+function record(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new AuthorBridgeError("Invalid request.", 400);
+	return value;
+}
+function text(value, key) {
+	const result = record(value)[key];
+	if (typeof result !== "string" || result === "") throw new AuthorBridgeError(`Invalid ${key}.`, 400);
+	return result;
+}
+function generation(value) {
+	const result = record(value).generation;
+	if (!Number.isSafeInteger(result) || result < 0) throw new AuthorBridgeError("Invalid generation.", 400);
+	return result;
+}
+async function body(request) {
+	return record(await request.json());
+}
+function createAuthorBridgeApi(state) {
+	const app = new Hono();
+	app.onError((error, context) => context.json({ error: error instanceof Error ? error.message : String(error) }, error instanceof AuthorBridgeError ? error.status : 500));
+	app.post(apiRoutes_default.bridgeRegister.path, async (context) => {
+		const value = await body(context.req.raw);
+		return context.json(state.register(text(value, "bindingId"), generation(value)));
+	});
+	app.post(apiRoutes_default.bridgeCatalog.path, async (context) => {
+		const value = await body(context.req.raw);
+		const tools = value.tools;
+		if (!Array.isArray(tools)) throw new AuthorBridgeError("Invalid Author catalog.", 400);
+		return context.json(state.catalog(text(value, "bindingId"), generation(value), text(value, "ownerToken"), tools));
+	});
+	app.post(apiRoutes_default.bridgeNext.path, async (context) => {
+		const value = await body(context.req.raw);
+		return context.json(await state.next(text(value, "bindingId"), generation(value), text(value, "ownerToken"), context.req.raw.signal));
+	});
+	app.post(apiRoutes_default.bridgeResult.path, async (context) => {
+		const value = await body(context.req.raw);
+		state.result(text(value, "bindingId"), generation(value), text(value, "ownerToken"), text(value, "catalogToken"), text(value, "requestId"), value.result);
+		return context.json({ accepted: true });
+	});
+	app.post(apiRoutes_default.bridgeCancelled.path, async (context) => {
+		const value = await body(context.req.raw);
+		state.cancelled(text(value, "bindingId"), generation(value), text(value, "ownerToken"), text(value, "catalogToken"), text(value, "requestId"));
+		return context.json({ accepted: true });
+	});
+	app.post(apiRoutes_default.bridgeDisconnect.path, async (context) => {
+		const value = await body(context.req.raw);
+		state.disconnect(text(value, "bindingId"), generation(value));
+		return context.json({ accepted: true });
+	});
+	app.get(apiRoutes_default.bridgeDescribe.path, (context) => context.json(state.describe()));
+	app.post(apiRoutes_default.bridgeInvoke.path, async (context) => {
+		const value = parseUseAuthorToolInput(await context.req.raw.json());
+		return context.json(await state.invoke(value, context.req.raw.signal));
+	});
+	return app;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/author/_lib/authorDocumentApi.ts
+const FORMATS = /* @__PURE__ */ new Set([
+	"markdown-slides",
+	"csv",
+	"pptx",
+	"xlsx"
+]);
+function errorResponse(context, error) {
+	const message = error instanceof Error ? error.message : "Document operation failed.";
+	const status = /limit|too many|exceeds/i.test(message) ? 413 : /outside/i.test(message) ? 403 : 422;
+	return context.json({ error: message }, status);
+}
+function requestFormat(value) {
+	if (typeof value !== "string" || !FORMATS.has(value)) throw new Error("A supported format is required.");
+	return value;
+}
+function requestOperations(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > 1e5) throw new Error("A bounded operations array is required.");
+	return value.map((operation) => {
+		if (typeof operation !== "object" || operation === null || typeof operation.fragmentId !== "string" || typeof operation.replacement !== "string") throw new Error("Each operation requires string fragmentId and replacement fields.");
+		return operation;
+	});
+}
+async function bodyOf(request) {
+	const body = await request.json();
+	if (typeof body !== "object" || body === null || Array.isArray(body)) throw new Error("A JSON object is required.");
+	return body;
+}
+function createAuthorDocumentApi(options = {}) {
+	const app = new Hono();
+	const cwd = options.cwd ?? process.cwd();
+	app.post(apiRoutes_default.documentsOpen.path, async (context) => {
+		try {
+			const body = await bodyOf(context.req.raw);
+			const bytes = await readDocument(cwd, body.path);
+			if (body.format === void 0) return context.json({
+				path: body.path,
+				byteLength: bytes.byteLength
+			});
+			return context.json(await parseStructuredDocument(requestFormat(body.format), bytes, body.csvDialect));
+		} catch (error) {
+			return errorResponse(context, error);
+		}
+	});
+	app.post(apiRoutes_default.documentsPreflight.path, async (context) => {
+		try {
+			const body = await bodyOf(context.req.raw);
+			const bytes = await readDocument(cwd, body.path);
+			return context.json(await preflightStructuredDocument(requestFormat(body.format), bytes, requestOperations(body.operations), body.csvDialect));
+		} catch (error) {
+			return errorResponse(context, error);
+		}
+	});
+	app.post(apiRoutes_default.documentsSerialize.path, async (context) => {
+		try {
+			const body = await bodyOf(context.req.raw);
+			if (typeof body.preflightDigest !== "string") throw new Error("A preflight report digest is required.");
+			const bytes = await readDocument(cwd, body.path);
+			const serialized = await serializeStructuredDocument(requestFormat(body.format), bytes, requestOperations(body.operations), body.preflightDigest, body.csvDialect);
+			return context.json({
+				bytes: Buffer.from(serialized.bytes).toString("base64"),
+				encoding: "base64",
+				manifest: serialized.manifest,
+				operationLog: serialized.operationLog
+			});
+		} catch (error) {
+			return errorResponse(context, error);
+		}
+	});
+	return app;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/author/_lib/authorApi.ts
+const inactiveState = () => ({
+	activation: "inactive",
+	capabilityCount: 0
+});
+const createBridge = () => createAuthorBridgeState({
+	now: Date.now,
+	issueToken: randomUUID,
+	scheduleTimeout(callback, delayMs) {
+		const timer = setTimeout(callback, delayMs);
+		timer.unref?.();
+		return () => clearTimeout(timer);
+	}
+});
+function createAuthorApi(options = {}) {
+	const app = new Hono();
+	const bridge = options.bridge ?? createBridge();
+	app.get(apiRoutes_default.state.path, (context) => context.json({
+		sessionId: options.sessionId ?? null,
+		...(options.readState ?? inactiveState)()
+	}));
+	app.route("/", createAuthorBridgeApi(bridge));
+	app.route("/", createAuthorDocumentApi(options.cwd === void 0 ? {} : { cwd: options.cwd }));
+	return app;
+}
+const api = {
+	basePath: API_BASE_PATH,
+	start(context) {
+		const bridge = createBridge();
+		const app = createAuthorApi({
+			...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+			...context.cwd === void 0 ? {} : { cwd: context.cwd },
+			bridge
+		});
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => bridge.close()
+		};
+	}
+};
+/** The session API and tools share the same browser ownership and pending requests. */
+function createAuthorSessionApi(cwd, sessionId) {
+	const bridge = createBridge();
+	return {
+		catalog: {
+			async open(path, signal) {
+				signal?.throwIfAborted();
+				return {
+					path,
+					byteLength: (await readDocument(cwd, path)).byteLength
+				};
+			},
+			async describe(signal) {
+				signal?.throwIfAborted();
+				return bridge.describe();
+			},
+			execute: (input, signal) => bridge.invoke(input, signal)
+		},
+		api: {
+			basePath: API_BASE_PATH,
+			start() {
+				const app = createAuthorApi({
+					cwd,
+					sessionId,
+					bridge
+				});
+				return {
+					fetch: (request) => app.fetch(request),
+					close: () => bridge.close()
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(({ agent }) => {
+	const session = agent ? createAuthorSessionApi(agent.context.cwd, agent.context.sessionId) : void 0;
+	const mode = agent ? authorMinorMode.createOwner({
+		isActive: () => (agent.context.selection.state?.["minor-mode"] ?? []).includes(authorMinorMode.descriptor.id),
+		detail: () => "document authoring available",
+		async setActive(enabled) {
+			const modes = (agent.context.selection.state?.["minor-mode"] ?? []).filter((id) => id !== authorMinorMode.descriptor.id);
+			await agent.changeSelection({
+				axis: "state",
+				key: "minor-mode",
+				values: enabled ? [...modes, authorMinorMode.descriptor.id] : modes
+			});
+		}
+	}) : void 0;
+	return {
+		value: {
+			api: session?.api ?? api,
+			catalog: createAuthorCatalog(session?.catalog),
+			assertAvailable: () => void 0,
+			service: void 0
+		},
+		services: mode ? [serverMinorModes([mode])] : []
+	};
+});
+//#endregion
+//#region src/types/webAuthor.ts
+const authorChannelType = "author_webmcp";
+//#endregion
+//#region src/services/webAuthorChannel/index.ts
+/**
+* Which route carries each message the browser sends.
+*
+* The paths come from the package's one route table, so the hub cannot address
+* a bridge route the session no longer serves. `release` is absent because it
+* is answered by the disconnect route rather than one of its own.
+*/
+const BRIDGE_ROUTE = {
+	register: apiRoutes_default.bridgeRegister.path,
+	catalog: apiRoutes_default.bridgeCatalog.path,
+	result: apiRoutes_default.bridgeResult.path,
+	cancelled: apiRoutes_default.bridgeCancelled.path
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function browserMessage(value) {
+	if (!isRecord(value) || typeof value.kind !== "string") return void 0;
+	if (![
+		"register",
+		"release",
+		"catalog",
+		"result",
+		"cancelled"
+	].includes(value.kind)) return void 0;
+	return value;
+}
+async function responsePayload(response) {
+	const value = await response.json();
+	if (response.ok) return value;
+	return {
+		kind: "rejected",
+		reason: isRecord(value) && typeof value.error === "string" ? value.error : `Author bridge HTTP ${response.status}`
+	};
+}
+function createAuthorChannel() {
+	const bindings = /* @__PURE__ */ new Map();
+	let host;
+	let closed = false;
+	const keyOf = (sessionId, connectionId) => `${sessionId}\0${connectionId}`;
+	const send = async (scope, path, value, signal) => await host.requestSessionApi(scope, {
+		basePath: API_BASE_PATH,
+		path,
+		method: "POST",
+		body: JSON.stringify(value),
+		...signal === void 0 ? {} : { signal }
+	});
+	const publish = (binding, payload) => host?.publishToConnection?.(binding.connectionId, binding.scope.sessionId, payload) ?? false;
+	const poll = async (binding) => {
+		binding.poll?.abort();
+		const controller = new AbortController();
+		binding.poll = controller;
+		while (!closed && bindings.get(keyOf(binding.scope.sessionId, binding.connectionId)) === binding) try {
+			const payload = await responsePayload(await send(binding.scope, apiRoutes_default.bridgeNext.path, {
+				bindingId: binding.connectionId,
+				generation: binding.generation,
+				ownerToken: binding.ownerToken
+			}, controller.signal));
+			if (!publish(binding, payload) || payload.kind === "rejected") break;
+		} catch (error) {
+			if (!controller.signal.aborted) host?.onNotice(error instanceof Error ? error.message : String(error));
+			break;
+		}
+	};
+	return {
+		frameType: authorChannelType,
+		lifecycle: "hub",
+		receiveWithoutSubscription: true,
+		start(channelHost) {
+			host = channelHost;
+			return {
+				payloadFor: () => void 0,
+				sessionRemoved(sessionId) {
+					for (const [key, binding] of bindings) {
+						if (binding.scope.sessionId !== sessionId) continue;
+						binding.poll?.abort();
+						bindings.delete(key);
+						send(binding.scope, apiRoutes_default.bridgeDisconnect.path, {
+							bindingId: binding.connectionId,
+							generation: binding.generation
+						}).catch((error) => host?.onNotice(error instanceof Error ? error.message : String(error)));
+					}
+				},
+				close() {
+					closed = true;
+					for (const binding of bindings.values()) {
+						binding.poll?.abort();
+						send(binding.scope, apiRoutes_default.bridgeDisconnect.path, {
+							bindingId: binding.connectionId,
+							generation: binding.generation
+						}).catch((error) => host?.onNotice(error instanceof Error ? error.message : String(error)));
+					}
+					bindings.clear();
+				}
+			};
+		},
+		receive(scope, payload, connection) {
+			const message = browserMessage(payload);
+			if (message === void 0 || host === void 0 || closed) return;
+			(async () => {
+				const key = keyOf(scope.sessionId, connection.connectionId);
+				const previous = bindings.get(key);
+				if (message.kind === "release") {
+					if (previous === void 0 || previous.generation !== message.generation) return;
+					previous.poll?.abort();
+					bindings.delete(key);
+					await send(scope, apiRoutes_default.bridgeDisconnect.path, {
+						bindingId: connection.connectionId,
+						generation: message.generation
+					});
+					return;
+				}
+				const route = BRIDGE_ROUTE[message.kind];
+				const reply = await responsePayload(await send(scope, route, {
+					...message,
+					bindingId: connection.connectionId
+				}));
+				if (reply.kind === "accepted") {
+					const binding = {
+						scope,
+						connectionId: connection.connectionId,
+						generation: reply.generation,
+						ownerToken: reply.ownerToken
+					};
+					previous?.poll?.abort();
+					bindings.set(key, binding);
+					publish(binding, reply);
+					poll(binding);
+				} else if (reply.kind === "rejected" && previous !== void 0) publish(previous, reply);
+			})().catch((error) => host?.onNotice(error instanceof Error ? error.message : String(error)));
+		},
+		disconnected(connection) {
+			for (const [key, binding] of bindings) {
+				if (binding.connectionId !== connection.connectionId) continue;
+				binding.poll?.abort();
+				bindings.delete(key);
+				send(binding.scope, apiRoutes_default.bridgeDisconnect.path, {
+					bindingId: binding.connectionId,
+					generation: binding.generation
+				}).catch((error) => host?.onNotice(error instanceof Error ? error.message : String(error)));
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/(backend)/channel/author-webmcp.server.ts
+var author_webmcp_server_default = defineChannel(createAuthorChannel);
+//#endregion
+//#region src/services/authorBridgeMethod/index.ts
+function createAuthorBridgeMethod(scope, host) {
+	return defineServerMethod(authorBridgeMethod(scope), ({ sessionId, message }, caller) => {
+		if (!caller.connectionId) throw new Error("Author bridge requires an authenticated browser connection.");
+		if (!host.context.receiveChannel?.(sessionId, "author_webmcp", message, caller.connectionId)) throw new Error("Author bridge session is outside this mount.");
+		return {};
+	});
+}
+//#endregion
+//#region src/extensions/(backend)/method/bridge.server.ts
+var bridge_server_default = defineMethod(({ host }) => host.scope === "session" ? { register: () => ({ dispose: () => void 0 }) } : createAuthorBridgeMethod(host.scope, host));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/author/route.server.ts
+var route_server_default = defineRoute((context) => context.root.api);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/author.server.ts
+var author_server_default = defineCommand((context) => createAuthorCommand(context.root.service));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/before-agent-start.server.ts
+var before_agent_start_server_default = defineHook({
+	when: {
+		state: { "minor-mode": "author" },
+		attribution: {
+			kind: "minor",
+			mode: "author"
+		}
+	},
+	event: "before_agent_start",
+	handle(event) {
+		return { systemPrompt: `${typeof event.systemPrompt === "string" ? event.systemPrompt : ""}\n\n${AUTHOR_GUIDANCE}`.trim() };
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/doompi-use-author.server.ts
+var doompi_use_author_server_default = defineResource({
+	when: {
+		state: { "minor-mode": "author" },
+		attribution: {
+			kind: "minor",
+			mode: "author"
+		}
+	},
+	name: "doompi-use-author",
+	kind: "skill",
+	read: () => readPackageResource(import.meta.url, "src/prompts/doompi-use-author/SKILL.md")
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/describe-author-tools.server.ts
+var describe_author_tools_server_default = defineTool((context) => ({
+	...createAuthorTools(context.root.catalog, context.root.assertAvailable)[1],
+	when: AUTHOR_TOOL_WHEN
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/open-authoring-file.server.ts
+var open_authoring_file_server_default = defineTool((context) => ({
+	...createAuthorTools(context.root.catalog, context.root.assertAvailable)[0],
+	when: AUTHOR_TOOL_WHEN
+}));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/use-author-tools.server.ts
+var use_author_tools_server_default = defineTool((context) => ({
+	...createAuthorTools(context.root.catalog, context.root.assertAvailable)[2],
+	when: AUTHOR_TOOL_WHEN
+}));
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => ({
+	...identity,
+	...value
+});
+const facet = defineServerPlugin({
+	name: "@agimon-ai/doompi-author",
+	global: (context) => ({
+		get channels() {
+			return [() => via({ frameType: "author_webmcp" }, author_webmcp_server_default())];
+		},
+		get methods() {
+			return [at(bridge_server_default, context)];
+		}
+	}),
+	workspace: (context) => ({
+		get channels() {
+			return [() => via({ frameType: "author_webmcp" }, author_webmcp_server_default())];
+		},
+		get methods() {
+			return [at(bridge_server_default, context)];
+		}
+	}),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return [at(route_server_default, contextSession)];
+			},
+			get channels() {
+				return [() => via({ frameType: "author_webmcp" }, author_webmcp_server_default())];
+			},
+			get commands() {
+				return [via({ name: "author" }, at(author_server_default, contextSession))];
+			},
+			get hooks() {
+				return [via({ event: "before_agent_start" }, at(before_agent_start_server_default, contextSession))];
+			},
+			get methods() {
+				return [at(bridge_server_default, context)];
+			},
+			get resources() {
+				return [at(doompi_use_author_server_default, contextSession)];
+			},
+			get tools() {
+				return [
+					via({ name: "describe_author_tools" }, at(describe_author_tools_server_default, contextSession)),
+					via({ name: "open_authoring_file" }, at(open_authoring_file_server_default, contextSession)),
+					via({ name: "use_author_tools" }, at(use_author_tools_server_default, contextSession))
+				];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map