@agimon-ai/po-task 0.0.0-alpha.4 → 0.0.0-alpha.41

package/dist/extensions/server.cjs

@@ -6,23 +6,24 @@ const require_paths = require("../paths-P-XvOUuH.cjs");
 const require_config = require("../config-BC-bztyx.cjs");
 const require_taskGraph = require("../taskGraph-BskRslrr.cjs");
 const require_telemetry = require("../telemetry-x3JxCA5K.cjs");
-const require_delegation = require("../delegation-frvEXhIz.cjs");
+const require_delegation = require("../delegation-DRp6iZid.cjs");
 const require_taskResult = require("../taskResult-D2G7b4w-.cjs");
 const require_task = require("../task-UvW877Ez.cjs");
 const require_reducer = require("../reducer-BV0YIZ2o.cjs");
 const require_taskStore = require("../taskStore-C4vcUOzA.cjs");
-const require_logSinkTelemetry = require("../logSinkTelemetry-BGb8WQBz.cjs");
+const require_logSinkTelemetry = require("../logSinkTelemetry-DhzIQMsV.cjs");
 let _agimon_ai_po_core_delegation = require("@agimon-ai/po-core/delegation");
 let node_path = require("node:path");
 node_path = require_paths.__toESM(node_path, 1);
-let _agimon_ai_po_core_serverFacet = require("@agimon-ai/po-core/serverFacet");
+let _agimon_ai_po_core_serverPlugin = require("@agimon-ai/po-core/serverPlugin");
 let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
 let _agimon_ai_po_core_backgroundWork = require("@agimon-ai/po-core/backgroundWork");
+let _agimon_ai_po_core_codemode = require("@agimon-ai/po-core/codemode");
 let _agimon_ai_po_core_contextContributions = require("@agimon-ai/po-core/contextContributions");
 let _agimon_ai_po_core_readiness = require("@agimon-ai/po-core/readiness");
 let node_crypto = require("node:crypto");
-let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
 let typebox_value = require("typebox/value");
+let _agimon_ai_po_core_hubChannel = require("@agimon-ai/po-core/hubChannel");
 //#region src/services/contextContribution/index.ts
 const TASK_CONTEXT_CONTRIBUTION_SOURCE = "@agimon-ai/po-task";
 const TASK_CONTEXT_CONTRIBUTION_ID = "active-tasks";
@@ -82,6 +83,298 @@ function createNodeDelegationPlatform(environment = process.env) {
 	};
 }
 //#endregion
+//#region src/services/taskTool/index.ts
+function output(value) {
+	if (typeof value === "object" && value !== null && "content" in value) return value;
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		}],
+		details: value
+	};
+}
+function failure(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+async function reducerAction(store, action, params, maxTasks) {
+	const { document, value } = await store.mutate((current) => {
+		const result = require_reducer.applyTaskMutation(current, action, params, void 0, maxTasks);
+		return {
+			...require_reducer.isCommittingOp(result.op) ? { document: result.document } : {},
+			value: result
+		};
+	});
+	if (value.op.kind === "error") throw new Error(value.op.message);
+	return require_taskResult.buildToolResult(action, params, document, value.op);
+}
+async function assignmentBatch(manager, assignments, signal) {
+	const result = [];
+	for (const [index, assignment] of assignments.entries()) try {
+		const outcome = await manager.assign(assignment.id, {
+			agent: assignment.agent,
+			inlineAgent: assignment.inlineAgent,
+			instructions: assignment.instructions,
+			relevantFiles: assignment.relevantFiles,
+			priorFindings: assignment.priorFindings,
+			model: assignment.model,
+			...assignment.context === "fork" || assignment.context === "fresh" ? { context: assignment.context } : {},
+			signal
+		});
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			...outcome
+		});
+	} catch (error) {
+		result.push({
+			index,
+			id: assignment.id,
+			agent: assignment.agent,
+			ok: false,
+			message: String(error)
+		});
+	}
+	return result;
+}
+/** One task action against the session store, shared by the `task` tool and the `tasks` code-mode namespace. */
+async function runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate) {
+	if (!(0, typebox_value.Check)(require_task.TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
+	const params = rawParams;
+	try {
+		if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
+		if (params.action === "assign") {
+			if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
+			onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
+			const items = await assignmentBatch(manager, params.assignments, signal);
+			const assigned = items.filter((item) => item.ok).map((item) => item.id);
+			const text = require_taskResult.formatAssignmentResults(items);
+			if (assigned.length === 0) throw new Error(text);
+			return require_taskResult.buildAssignmentResult(params, store.snapshot, text, {
+				assigned,
+				failed: items.length - assigned.length
+			});
+		}
+		if (params.action === "cancel") {
+			const outcome = await manager.cancel(params.id ?? NaN);
+			if (!outcome.ok) throw new Error(outcome.message);
+			return require_taskResult.buildTextResult("cancel", params, store.snapshot, outcome.message);
+		}
+		return reducerAction(store, params.action, params, maxTasks);
+	} catch (error) {
+		return failure(error);
+	}
+}
+function createHeadlessTaskTool(store, manager, maxTasks) {
+	return {
+		name: "task",
+		label: "Task",
+		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
+		parameters: require_task.TaskParamsSchema,
+		promptSnippet: "Track complex work persistently and delegate ready tasks",
+		executionMode: "serial",
+		execute: (_toolCallId, rawParams, signal, onUpdate) => runTaskAction(store, manager, maxTasks, rawParams, signal, onUpdate)
+	};
+}
+//#endregion
+//#region src/services/taskNamespace/index.ts
+const DECLARATIONS = `type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'deleted';
+
+type DelegationState = 'requested' | 'running' | 'completed' | 'failed' | 'cancelled';
+
+interface DelegationResult {
+  status: string;
+  output?: string;
+  outputPath?: string;
+  sessionFile?: string;
+  error?: string;
+  durationMs?: number;
+  toolCount?: number;
+}
+
+interface TaskDelegation {
+  requestId: string;
+  agent: string;
+  identity?: string;
+  state: DelegationState;
+  sessionId?: string;
+  pid?: number;
+  runId?: string;
+  model?: string;
+  startedAt?: string;
+  endedAt?: string;
+  result?: DelegationResult;
+}
+
+interface Task {
+  id: number;
+  subject: string;
+  description?: string;
+  activeForm?: string;
+  status: TaskStatus;
+  blockedBy?: number[];
+  owner?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+  delegation?: TaskDelegation;
+}
+
+interface TaskDocument {
+  version: number;
+  rev: number;
+  nextId: number;
+  tasks: Task[];
+}
+interface TaskItem {
+  /** Existing task id to change. Omit to create; an unknown id fails only that entry. */
+  id?: number;
+  /** Temporary name so a LATER entry in the same call can list it in blockedBy. Never stored. */
+  ref?: string;
+  /** Short and imperative. Required when creating. */
+  subject?: string;
+  /** The durable brief handed to a subagent on assign. */
+  description?: string;
+  /** Present-continuous label shown while in_progress, such as 'writing tests'. */
+  activeForm?: string;
+  status?: TaskStatus;
+  /** For a NEW entry: task ids or earlier refs. */
+  blockedBy?: (number | string)[];
+  /** For an entry with an id: dependencies to add or remove. */
+  addBlockedBy?: (number | string)[];
+  removeBlockedBy?: (number | string)[];
+  owner?: string;
+  /** Merged into the task; a null value deletes that key. */
+  metadata?: Record<string, unknown>;
+}
+
+interface TaskAssignment {
+  /** A pending, unblocked task. */
+  id: number;
+  /** Exact name from subagent({ action: 'agents' }). */
+  agent: string;
+  instructions?: string;
+  /** Only files you actually read or located. */
+  relevantFiles?: string[];
+  /** Only verified facts, not directives. */
+  priorFindings?: string;
+  model?: string;
+  context?: 'fresh' | 'fork';
+}
+
+/** What a write returns: the text the task tool would print, and the graph after the write. */
+interface TaskWrite {
+  message: string;
+  document: TaskDocument;
+  /** upsert only: ids that landed and how many entries failed. Nothing landing throws; a partial failure does not. */
+  applied?: number[];
+  failed?: number;
+}
+declare const tasks: {
+  /** The whole task graph, tombstones included. Filter it in the script. */
+  snapshot(): Promise<TaskDocument>;
+  /**
+   * Create or change tasks, applied in array order. Never mark a task completed while tests fail or the
+   * work is partial: use failed, or keep it in_progress and add a task for the blocker in the same call.
+   * Status flow is pending, in_progress, completed. failed is recoverable and deleted is a tombstone.
+   */
+  upsert(tasks: TaskItem[]): Promise<TaskWrite>;
+  /** Tombstone one task. Refused while it has a running delegation. */
+  delete(id: number): Promise<TaskWrite>;
+  /** Remove every task. Refused while a delegation is running. */
+  clear(): Promise<TaskWrite>;
+  /** Hand ready tasks to background subagents. Batch independent tasks in one call. */
+  assign(assignments: TaskAssignment[]): Promise<TaskWrite>;
+  /** Cancel a task's running delegation. */
+  cancel(id: number): Promise<TaskWrite>;
+};`;
+/** The owning session's task graph: `snapshot` reads without locking, the rest write through the same store as the `task` tool. */
+function createTaskNamespace(options) {
+	return {
+		name: "tasks",
+		summary: "The session task graph: tasks.snapshot() reads it, tasks.upsert/delete/clear change it, tasks.assign/cancel hand tasks to background subagents. Use it to track multi-step work.",
+		declarations: DECLARATIONS,
+		bind(run) {
+			if (run.sessionId !== options.sessionId) throw new Error("Tasks namespace belongs to another session.");
+			let disposed = false;
+			run.onDispose(() => {
+				disposed = true;
+			});
+			const assertAvailable = () => {
+				run.signal.throwIfAborted();
+				if (disposed) throw new Error("Tasks namespace run is disposed.");
+				options.assertAvailable();
+			};
+			const members = Object.create(null);
+			members.snapshot = async () => {
+				assertAvailable();
+				const storePath = options.store.storePath;
+				const errors = [];
+				const document = await options.store.readAsync(() => false, (error) => errors.push(error));
+				assertAvailable();
+				if (options.store.storePath !== storePath) throw new Error("Task store path changed during snapshot.");
+				if (errors.length > 0) throw new Error("Task snapshot read failed.", { cause: errors[0] });
+				return JSON.parse(JSON.stringify(document));
+			};
+			const write = async (params) => {
+				assertAvailable();
+				const started = Date.now();
+				const result = await runTaskAction(options.store, options.manager, options.maxTasks, params, run.signal);
+				assertAvailable();
+				const message = result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+				const upsert = result.details?.upsert;
+				const failure = result.isError || upsert && upsert.applied.length === 0 && upsert.failed > 0 ? message : void 0;
+				run.record?.({
+					name: `tasks.${String(params.action)}`,
+					tool: "task",
+					args: params,
+					ok: failure === void 0,
+					ms: Date.now() - started,
+					...failure === void 0 ? {} : { error: failure },
+					result: {
+						content: result.content,
+						details: result.details
+					}
+				});
+				if (failure !== void 0) throw new Error(failure);
+				return {
+					message,
+					document: JSON.parse(JSON.stringify(options.store.snapshot)),
+					...upsert ? {
+						applied: upsert.applied,
+						failed: upsert.failed
+					} : {}
+				};
+			};
+			members.upsert = (tasks) => write({
+				action: "upsert",
+				tasks
+			});
+			members.delete = (id) => write({
+				action: "delete",
+				id
+			});
+			members.clear = () => write({ action: "clear" });
+			members.assign = (assignments) => write({
+				action: "assign",
+				assignments
+			});
+			members.cancel = (id) => write({
+				action: "cancel",
+				id
+			});
+			return members;
+		}
+	};
+}
+//#endregion
 //#region src/types/webTasks.ts
 /** Browser-safe task view published by the cockpit hub channel. */
 const TASKS_CHANNEL_TYPE = "task_graph";
@@ -95,7 +388,7 @@ function headlineOf(content) {
 const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHost, agent: host, signal: pluginSignal }) => {
 	if (!host) throw new Error("Task session requires the headless host.");
 	const execution = host.context;
-	if (serverHost.context.directEvents === void 0) throw new Error("Task headless facet requires the session direct event bus.");
+	if (serverHost.context.directEvents === void 0) throw new Error("Task server plugin requires the session direct event bus.");
 	const directEvents = serverHost.context.directEvents;
 	const reporter = require_logSinkTelemetry.createTaskErrorReporter({
 		cwd: execution.cwd,
@@ -180,6 +473,25 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHos
 		},
 		services: [(serviceContextOwner) => {
 			serviceContext = serviceContextOwner;
+			const namespace = createTaskNamespace({
+				store,
+				manager,
+				maxTasks,
+				sessionId: execution.sessionId,
+				assertAvailable: () => {
+					if (!active || disposed || pluginSignal?.aborted) throw new Error("Task session is unavailable.");
+				}
+			});
+			serviceContextOwner.inject([_agimon_ai_po_core_codemode.PO_CODEMODE_SERVICE], (context) => {
+				const codemode = (0, _agimon_ai_po_core_codemode.readPoCodemode)(context);
+				if (!codemode) return void 0;
+				const registration = codemode.register(SOURCE, namespace);
+				const restriction = host.registerToolRestriction({ excludedTools: ["task"] });
+				return () => {
+					restriction.dispose();
+					registration.dispose();
+				};
+			});
 			serviceContextOwner.inject([_agimon_ai_po_core_contextContributions.PO_CONTEXT_CONTRIBUTIONS_SERVICE], (context) => {
 				const registration = (0, _agimon_ai_po_core_contextContributions.requirePoContextContributions)(context).register(createTaskContextContribution(() => active && !disposed ? store.snapshot.tasks : []));
 				return () => registration.dispose();
@@ -282,12 +594,14 @@ const root = (0, _agimon_ai_po_core_extensionFile.defineRoot)(({ host: serverHos
 			generation += 1;
 			startupAbort.abort();
 			await Promise.allSettled([startup]);
-			unwatch?.();
-			background?.dispose();
-			manager.dispose();
-			store.dispose();
-			await ownedReadiness.dispose();
-			await reporter.shutdown();
+			await (0, _agimon_ai_po_core_extensionFile.runCleanups)([
+				() => unwatch?.(),
+				() => background?.dispose(),
+				() => manager.dispose(),
+				() => store.dispose(),
+				() => ownedReadiness.dispose(),
+				() => reporter.shutdown()
+			], "Task cleanup failed.");
 		}
 	};
 });
@@ -315,6 +629,7 @@ function present(document) {
 			if (task.updatedAt) view.updatedAt = task.updatedAt;
 			if (task.delegation) view.delegation = {
 				...task.delegation.agent === void 0 ? {} : { agent: task.delegation.agent },
+				...task.delegation.identity === void 0 ? {} : { identity: task.delegation.identity },
 				...task.delegation.state === void 0 ? {} : { state: task.delegation.state }
 			};
 			return [view];
@@ -434,105 +749,6 @@ function createTasksChannel(options = {}) {
 //#region src/extensions/(backend)/channel/task-graph.server.ts
 var task_graph_server_default = (0, _agimon_ai_po_core_extensionFile.defineChannel)(createTasksChannel);
 //#endregion
-//#region src/services/taskTool/index.ts
-function output(value) {
-	if (typeof value === "object" && value !== null && "content" in value) return value;
-	return {
-		content: [{
-			type: "text",
-			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-		}],
-		details: value
-	};
-}
-function failure(error) {
-	return {
-		content: [{
-			type: "text",
-			text: error instanceof Error ? error.message : String(error)
-		}],
-		isError: true
-	};
-}
-async function reducerAction(store, action, params, maxTasks) {
-	const { document, value } = await store.mutate((current) => {
-		const result = require_reducer.applyTaskMutation(current, action, params, void 0, maxTasks);
-		return {
-			...require_reducer.isCommittingOp(result.op) ? { document: result.document } : {},
-			value: result
-		};
-	});
-	if (value.op.kind === "error") throw new Error(value.op.message);
-	return require_taskResult.buildToolResult(action, params, document, value.op);
-}
-async function assignmentBatch(manager, assignments, signal) {
-	const result = [];
-	for (const [index, assignment] of assignments.entries()) try {
-		const outcome = await manager.assign(assignment.id, {
-			agent: assignment.agent,
-			inlineAgent: assignment.inlineAgent,
-			instructions: assignment.instructions,
-			relevantFiles: assignment.relevantFiles,
-			priorFindings: assignment.priorFindings,
-			model: assignment.model,
-			...assignment.context === "fork" || assignment.context === "fresh" ? { context: assignment.context } : {},
-			signal
-		});
-		result.push({
-			index,
-			id: assignment.id,
-			agent: assignment.agent,
-			...outcome
-		});
-	} catch (error) {
-		result.push({
-			index,
-			id: assignment.id,
-			agent: assignment.agent,
-			ok: false,
-			message: String(error)
-		});
-	}
-	return result;
-}
-function createHeadlessTaskTool(store, manager, maxTasks) {
-	return {
-		name: "task",
-		label: "Task",
-		description: "Maintain a persistent task graph and delegate ready tasks to background agents.",
-		parameters: require_task.TaskParamsSchema,
-		promptSnippet: "Track complex work persistently and delegate ready tasks",
-		executionMode: "serial",
-		async execute(_toolCallId, rawParams, signal, onUpdate) {
-			if (!(0, typebox_value.Check)(require_task.TaskParamsSchema, rawParams)) return failure("Invalid task parameters.");
-			const params = rawParams;
-			try {
-				if ((params.action === "assign" || params.action === "cancel") && !manager) throw new Error("Delegation is not available on this connection.");
-				if (params.action === "assign") {
-					if (!params.assignments?.length) throw new Error("assign requires a non-empty assignments[] array");
-					onUpdate?.(output(`Delegating ${params.assignments.length} task${params.assignments.length === 1 ? "" : "s"}...`));
-					const items = await assignmentBatch(manager, params.assignments, signal);
-					const assigned = items.filter((item) => item.ok).map((item) => item.id);
-					const text = require_taskResult.formatAssignmentResults(items);
-					if (assigned.length === 0) throw new Error(text);
-					return require_taskResult.buildAssignmentResult(params, store.snapshot, text, {
-						assigned,
-						failed: items.length - assigned.length
-					});
-				}
-				if (params.action === "cancel") {
-					const outcome = await manager.cancel(params.id ?? NaN);
-					if (!outcome.ok) throw new Error(outcome.message);
-					return require_taskResult.buildTextResult("cancel", params, store.snapshot, outcome.message);
-				}
-				return reducerAction(store, params.action, params, maxTasks);
-			} catch (error) {
-				return failure(error);
-			}
-		}
-	};
-}
-//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/command/_lib/tasks.server.ts
 var tasks_server_default$1 = (context) => ({
 	name: require_task.COMMAND_NAME,
@@ -550,12 +766,22 @@ var tasks_server_default$1 = (context) => ({
 //#region src/extensions/workspaces/sessions/(backend)/command/tasks.server.ts
 var tasks_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerCommand)(tasks_server_default$1);
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/codemode-how-to-task.server.ts
+var codemode_how_to_task_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)({
+	name: "codemode-how-to-task",
+	description: "Keep a plan that survives compaction and delegate parts of it to background subagents. Use for any multi-step plan, todo list, or delegation.",
+	kind: "skill",
+	pinned: true,
+	path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-task/SKILL.md"),
+	read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-task/SKILL.md")
+});
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/resource/_lib/task-board.server.ts
 var task_board_server_default$1 = (context) => ({
 	name: "po/task-board",
 	kind: "context",
 	/**
-	* The same bounded projection the Pi facet renders: open work only, one line each.
+	* The same bounded projection the Pi extension renders: open work only, one line each.
 	* Dumping the whole TaskDocument put every completed task plus the store's own
 	* version/rev/nextId bookkeeping in the prompt, and an idle board still cost a
 	* paragraph. '' is dropped by the prompt composer.
@@ -577,21 +803,24 @@ var task_server_default = (0, _agimon_ai_po_core_extensionFile.defineServerTool)
 //#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 = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
+const serverPlugin = (0, _agimon_ai_po_core_serverPlugin.defineServerPlugin)({
 	name: "@agimon-ai/po-task",
-	providerOverrides: (0, _agimon_ai_po_core_serverFacet.composeServerProviderOverrides)(root_server_default),
-	global: () => ({ get channels() {
-		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	providerOverrides: (0, _agimon_ai_po_core_serverPlugin.composeServerProviderOverrides)(root_server_default),
+	injects: (0, _agimon_ai_po_core_extensionFile.composeRootInjects)({ session: [root_server_default] }),
+	global: (context) => ({ get channels() {
+		return [() => via({ frameType: "task_graph" }, at(task_graph_server_default, context))];
 	} }),
-	workspace: () => ({ get channels() {
-		return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+	workspace: (context) => ({ get channels() {
+		return defined([context.hosted("global") ? void 0 : () => via({ frameType: "task_graph" }, at(task_graph_server_default, context))]);
 	} }),
 	session: async (context) => {
-		const scopeSession = await root_server_default(context);
+		const scopeSession = await context.scopeRoot("session", root_server_default, context);
 		const contextSession = {
 			...context,
 			root: scopeSession.value
@@ -599,13 +828,13 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 		return {
 			...(0, _agimon_ai_po_core_extensionFile.composeRootHooks)(scopeSession),
 			get channels() {
-				return [() => via({ frameType: "task_graph" }, task_graph_server_default())];
+				return defined([context.hosted("global") ? void 0 : () => via({ frameType: "task_graph" }, at(task_graph_server_default, context))]);
 			},
 			get commands() {
 				return [via({ name: "tasks" }, at(tasks_server_default, contextSession))];
 			},
 			get resources() {
-				return [at(task_board_server_default, contextSession)];
+				return [at(codemode_how_to_task_server_default, contextSession), at(task_board_server_default, contextSession)];
 			},
 			get tools() {
 				return [via({ name: "task" }, at(task_server_default, contextSession))];
@@ -618,7 +847,7 @@ const facet = (0, _agimon_ai_po_core_serverFacet.defineServerPlugin)({
 	}
 });
 //#endregion
-exports.default = facet;
-exports.facet = facet;
+exports.default = serverPlugin;
+exports.serverPlugin = serverPlugin;
 
 //# sourceMappingURL=server.cjs.map