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

package/dist/extensions/server.mjs

@@ -0,0 +1,838 @@
+import { o as authorBridgeMethod } from "../authorFacade--Lc599Ft.mjs";
+import { A as AUTHOR_ALIAS_PATTERN, C as AuthorBridgeError, D as createAuthorTools, E as AUTHOR_TOOL_WHEN, I as AUTHOR_GUIDANCE, P as parseUseAuthorToolInput, T as createAuthorCatalog, _ as DocumentRequestError, b as authorMinorMode, n as preflightStructuredDocument, r as serializeStructuredDocument, t as parseStructuredDocument, v as documentTooLarge, w as createAuthorBridgeState, y as createAuthorCommand } from "../structuredDocuments-B914GLxx.mjs";
+import { composeServerProviderOverrides, defineServerMethod, defineServerPlugin, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { serverMinorModes } from "@agimon-ai/po-minor-mode";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { composeRootHooks, defineChannel, defineCommand as defineCommand$1, defineHook, defineMethod, defineResource, defineRoot, defineRoute, defineTool as defineTool$1 } from "@agimon-ai/po-core/extensionFile";
+import { Hono } from "hono";
+import fs from "node:fs/promises";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-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 DocumentRequestError("Document path is outside the working directory.", 403);
+	const realCandidate = await fs.realpath(candidate);
+	if (realCandidate !== root && !realCandidate.startsWith(`${root}${path.sep}`)) throw new DocumentRequestError("Document path is outside the working directory.", 403);
+	if ((await fs.stat(realCandidate)).size > 26214400) throw documentTooLarge(`Document exceeds the ${AUTHOR_DOCUMENT_MAX_BYTES} byte preview limit.`);
+	return await fs.readFile(realCandidate);
+}
+//#endregion
+//#region src/services/authorCanvasRegistry/index.ts
+const MAX_CANVASES = 32;
+function createAuthorCanvasRegistry(cwd, createBridge) {
+	const byAlias = /* @__PURE__ */ new Map();
+	const byPath = /* @__PURE__ */ new Map();
+	const select = (alias) => {
+		if (alias !== void 0) {
+			if (!AUTHOR_ALIAS_PATTERN.test(alias)) throw new AuthorBridgeError("Invalid Author canvas alias.", 400);
+			const canvas = byAlias.get(alias);
+			if (canvas === void 0) throw new AuthorBridgeError(`Unknown Author canvas '${alias}'. Call describe_author_tools({}) for available aliases.`, 404);
+			return canvas;
+		}
+		const canvases = [...byAlias.values()].filter((canvas) => !canvas.closed);
+		if (canvases.length !== 1) throw new AuthorBridgeError("Specify a canvas alias. Call describe_author_tools({}) to list canvases.", 409);
+		return canvases[0];
+	};
+	const view = (canvas) => {
+		if (canvas.closed) return {
+			alias: canvas.alias,
+			path: canvas.path,
+			status: "unavailable"
+		};
+		try {
+			canvas.bridge.describe();
+			canvas.readyOnce = true;
+			return {
+				alias: canvas.alias,
+				path: canvas.path,
+				status: "ready"
+			};
+		} catch {
+			return {
+				alias: canvas.alias,
+				path: canvas.path,
+				status: canvas.readyOnce ? "unavailable" : "opening"
+			};
+		}
+	};
+	return {
+		async open(requestedPath, signal, requestedAlias) {
+			signal?.throwIfAborted();
+			if (requestedAlias !== void 0 && !AUTHOR_ALIAS_PATTERN.test(requestedAlias)) throw new AuthorBridgeError("Invalid Author canvas alias.", 400);
+			const bytes = await readDocument(cwd, requestedPath);
+			signal?.throwIfAborted();
+			const root = await fs.realpath(cwd);
+			const realPath = await fs.realpath(path.resolve(root, requestedPath));
+			if (realPath !== root && !realPath.startsWith(`${root}${path.sep}`)) throw new AuthorBridgeError("Document path is outside the working directory.", 400);
+			const canonicalPath = path.relative(root, realPath).split(path.sep).join("/");
+			const occupied = requestedAlias === void 0 ? void 0 : byAlias.get(requestedAlias);
+			if (occupied !== void 0 && occupied.realPath !== realPath) throw new AuthorBridgeError(`Author canvas alias '${requestedAlias}' already names ${occupied.path}.`, 409);
+			const existing = byPath.get(realPath);
+			if (existing !== void 0) {
+				if (existing.closed) existing.readyOnce = false;
+				existing.closed = false;
+				return {
+					path: existing.path,
+					byteLength: bytes.byteLength,
+					alias: existing.alias,
+					status: view(existing).status,
+					reused: true
+				};
+			}
+			if (byAlias.size >= MAX_CANVASES) throw new AuthorBridgeError("Too many Author canvases in this conversation.", 409);
+			const base = path.basename(canonicalPath).replace(/\.[^.]*$/u, "").toLowerCase().replace(/[^a-z0-9_-]+/gu, "-").replace(/^[^a-z]+/u, "canvas-").slice(0, 48) || "canvas";
+			let alias = requestedAlias ?? base;
+			for (let suffix = 2; byAlias.has(alias); suffix++) alias = `${base.slice(0, 56)}-${suffix}`;
+			const canvas = {
+				alias,
+				path: canonicalPath,
+				realPath,
+				bridge: createBridge(),
+				closed: false,
+				readyOnce: false
+			};
+			byAlias.set(alias, canvas);
+			byPath.set(realPath, canvas);
+			return {
+				path: canonicalPath,
+				byteLength: bytes.byteLength,
+				alias,
+				status: "opening",
+				reused: false
+			};
+		},
+		describe(alias) {
+			const canvases = [...byAlias.values()].map(view);
+			const target = alias === void 0 && canvases.filter((canvas) => canvas.status !== "unavailable").length !== 1 ? void 0 : select(alias);
+			if (target === void 0) return {
+				catalogToken: "",
+				tools: [],
+				canvases,
+				nextStep: "Open a file with open_authoring_file, then describe_author_tools({\"alias\":\"canvas-name\"})."
+			};
+			const status = view(target).status;
+			const base = {
+				alias: target.alias,
+				path: target.path,
+				status,
+				canvases
+			};
+			if (status !== "ready") return {
+				...base,
+				catalogToken: "",
+				tools: [],
+				nextStep: status === "opening" ? `Wait for ${target.alias} to be ready, then call describe_author_tools({"alias":"${target.alias}"}).` : `Reopen ${target.path} with open_authoring_file({"path":"${target.path}","alias":"${target.alias}"}).`
+			};
+			return {
+				...base,
+				...target.bridge.describe()
+			};
+		},
+		invoke(input, signal) {
+			const target = select(input.alias);
+			if (target.closed) throw new AuthorBridgeError(`Canvas '${target.alias}' is closed. Reopen its file.`, 503);
+			return target.bridge.invoke(input, signal).then((result) => ({
+				...result,
+				alias: target.alias
+			}));
+		},
+		bridge(alias) {
+			const canvas = select(alias);
+			if (canvas.closed) throw new AuthorBridgeError(`Canvas '${alias}' is closed. Reopen its file.`, 503);
+			return canvas.bridge;
+		},
+		close(alias) {
+			const canvas = select(alias);
+			canvas.closed = true;
+			canvas.bridge.close();
+			canvas.bridge = createBridge();
+		},
+		closeAll() {
+			for (const canvas of byAlias.values()) {
+				if (canvas.closed) continue;
+				canvas.closed = true;
+				canvas.bridge.close();
+				canvas.bridge = createBridge();
+			}
+		},
+		dispose() {
+			for (const canvas of byAlias.values()) canvas.bridge.close();
+			byAlias.clear();
+			byPath.clear();
+		}
+	};
+}
+//#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"
+	},
+	bridgeClose: {
+		method: "POST",
+		path: "/bridge/close"
+	},
+	bridgeDescribe: {
+		method: "GET",
+		path: "/bridge/describe",
+		query: ["alias"]
+	},
+	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(registry) {
+	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);
+		const alias = text(value, "alias");
+		return context.json({
+			...registry.bridge(alias).register(text(value, "bindingId"), generation(value)),
+			alias
+		});
+	});
+	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);
+		const alias = text(value, "alias");
+		return context.json({
+			...registry.bridge(alias).catalog(text(value, "bindingId"), generation(value), text(value, "ownerToken"), tools),
+			alias
+		});
+	});
+	app.post(apiRoutes_default.bridgeNext.path, async (context) => {
+		const value = await body(context.req.raw);
+		const alias = text(value, "alias");
+		return context.json({
+			...await registry.bridge(alias).next(text(value, "bindingId"), generation(value), text(value, "ownerToken"), context.req.raw.signal),
+			alias
+		});
+	});
+	app.post(apiRoutes_default.bridgeResult.path, async (context) => {
+		const value = await body(context.req.raw);
+		registry.bridge(text(value, "alias")).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);
+		registry.bridge(text(value, "alias")).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);
+		registry.bridge(text(value, "alias")).disconnect(text(value, "bindingId"), generation(value));
+		return context.json({ accepted: true });
+	});
+	app.post(apiRoutes_default.bridgeClose.path, async (context) => {
+		const value = await body(context.req.raw);
+		registry.close(text(value, "alias"));
+		return context.json({ accepted: true });
+	});
+	app.get(apiRoutes_default.bridgeDescribe.path, (context) => context.json(registry.describe(context.req.query("alias"))));
+	app.post(apiRoutes_default.bridgeInvoke.path, async (context) => {
+		const value = parseUseAuthorToolInput(await context.req.raw.json());
+		return context.json(await registry.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.";
+	return context.json({ error: message }, error instanceof DocumentRequestError ? error.status : 422);
+}
+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);
+			if (body.format === void 0 && options.open !== void 0) return context.json(await options.open(body.path, context.req.raw.signal, body.alias));
+			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 registry = options.registry ?? createAuthorCanvasRegistry(options.cwd ?? process.cwd(), createBridge);
+	app.get(apiRoutes_default.state.path, (context) => context.json({
+		sessionId: options.sessionId ?? null,
+		...(options.readState ?? inactiveState)()
+	}));
+	app.route("/", createAuthorBridgeApi(registry));
+	app.route("/", createAuthorDocumentApi({
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		open: (path, signal, alias) => registry.open(path, signal, alias)
+	}));
+	return app;
+}
+const api = {
+	basePath: API_BASE_PATH,
+	start(context) {
+		if (context.cwd === void 0) throw new Error("Author requires the session working directory.");
+		const registry = createAuthorCanvasRegistry(context.cwd, createBridge);
+		const app = createAuthorApi({
+			...context.sessionId === void 0 ? {} : { sessionId: context.sessionId },
+			cwd: context.cwd,
+			registry
+		});
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => registry.dispose()
+		};
+	}
+};
+/** The session API and tools share the same browser ownership and pending requests. */
+function createAuthorSessionApi(cwd, sessionId) {
+	const registry = createAuthorCanvasRegistry(cwd, createBridge);
+	return {
+		closeCanvases: () => registry.closeAll(),
+		catalog: {
+			open: (path, signal, alias) => registry.open(path, signal, alias),
+			async describe(signal, alias) {
+				signal?.throwIfAborted();
+				return registry.describe(alias);
+			},
+			execute: (input, signal) => registry.invoke(input, signal)
+		},
+		api: {
+			basePath: API_BASE_PATH,
+			start() {
+				const app = createAuthorApi({
+					cwd,
+					sessionId,
+					registry
+				});
+				return {
+					fetch: (request) => app.fetch(request),
+					close: () => registry.dispose()
+				};
+			}
+		}
+	};
+}
+//#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 isActive = () => (agent?.context.selection.state?.["minor-mode"] ?? []).includes(authorMinorMode.descriptor.id);
+	const mode = agent ? authorMinorMode.createOwner({
+		isActive,
+		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
+			});
+			if (!enabled) session?.closeCanvases();
+		}
+	}) : void 0;
+	return {
+		value: {
+			api: session?.api ?? api,
+			catalog: createAuthorCatalog(session?.catalog),
+			assertAvailable: () => {
+				if (!isActive()) throw new Error("Author mode is not active.");
+			},
+			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" || typeof value.alias !== "string" || !AUTHOR_ALIAS_PATTERN.test(value.alias)) 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, alias) => `${sessionId}\0${connectionId}\0${alias}`;
+	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,
+		alias: binding.alias
+	}) ?? 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.alias)) === binding) try {
+			const payload = await responsePayload(await send(binding.scope, apiRoutes_default.bridgeNext.path, {
+				alias: binding.alias,
+				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, {
+							alias: binding.alias,
+							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, {
+							alias: binding.alias,
+							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, message.alias);
+				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, {
+						alias: message.alias,
+						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 = {
+						alias: message.alias,
+						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") {
+					if (previous !== void 0) publish(previous, reply);
+					else host?.publishToConnection?.(connection.connectionId, scope.sessionId, {
+						...reply,
+						alias: message.alias
+					});
+				}
+			})().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, {
+					alias: binding.alias,
+					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$1((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/po-use-author.server.ts
+var po_use_author_server_default = defineResource({
+	when: {
+		state: { "minor-mode": "author" },
+		attribution: {
+			kind: "minor",
+			mode: "author"
+		}
+	},
+	name: "po-use-author",
+	kind: "skill",
+	read: () => readPackageResource(import.meta.url, "src/prompts/po-use-author/SKILL.md")
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/describe-author-tools.server.ts
+var describe_author_tools_server_default = defineTool$1((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$1((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$1((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) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-author",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	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(po_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