neondeck 1.0.0-beta.10

package/dist/server.mjs

@@ -0,0 +1,583 @@
+import { Dt as verifyKiloResultAction, Et as reviewKiloResultAction, Ha as ensureRuntimeHomeSync, Ja as runtimePaths, Or as devDoctorRunAction, Tt as promoteKiloResultAction, _ as commentPrAutofixResultAction, at as kiloTaskReconcileAction, gn as watchPrAddAction, gt as summarizeKiloSession, ot as kiloTaskStartAction, to as __exportAll, v as fixPrCiFailureAction, w as verifyPrWorktreeAction, y as fixPrReviewFeedbackAction } from "./assets/autopilot-B8lfWyA1.js";
+import { a as busywork_workflow_exports, n as fix_pr_ci_exports } from "./assets/fix-pr-ci-Ce2SIcyf.js";
+import { n as display_assistant_exports, t as display_assistant_default } from "./assets/display-assistant-CKU4YJlc.js";
+import { a as pr_review_assistant_exports, n as review_pr_for_human_exports } from "./assets/review-pr-for-human-TPiQNRWV.js";
+import { n as scheduler_workflow_exports } from "./assets/scheduler-workflow-CnI0tWbg.js";
+import { n as briefing_exports } from "./assets/briefing-BT8h9XXT.js";
+import { n as command_run_exports } from "./assets/command-run-CnPOA8iY.js";
+import { c as curate_learning_store_exports, i as review_pr_batch_for_learning_exports, n as scheduler_tick_exports, o as review_conversation_for_learning_exports } from "./assets/scheduler-tick-B2S9jCYS.js";
+import { n as prepare_pr_worktree_exports } from "./assets/prepare-pr-worktree-C7SmiaTp.js";
+import { n as push_pr_autofix_exports } from "./assets/push-pr-autofix-CsMbrnXR.js";
+import { r as scheduled_agent_instruction_exports } from "./assets/scheduled-agent-instruction-C58itQyU.js";
+import { r as triage_pr_event_exports } from "./assets/triage-pr-event-IgC-IrNs.js";
+import { r as verify_then_push_pr_autofix_exports } from "./assets/verify-then-push-pr-autofix-C5Dpomtd.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { format } from "node:util";
+import { serve } from "@hono/node-server";
+import { Bash, InMemoryFs, admitDetachedWorkflow, assertWorkflowDefinition, bashFactoryToSessionEnv, configureFlueRuntime, createFlueContext, createInstrumentationOwner, createNodeAgentCoordinator, createNodeDispatchQueue, createRuntimeActivityGate, installDevLifecycleLogger, resolveModel, runWithInstrumentationOwner } from "@flue/runtime/internal";
+import { defineWorkflow } from "@flue/runtime";
+import * as v from "valibot";
+import { sqlite } from "@flue/runtime/node";
+//#region src/workflows/comment-pr-autofix-result.ts
+var comment_pr_autofix_result_exports = /* @__PURE__ */ __exportAll({
+	default: () => comment_pr_autofix_result_default,
+	runs: () => runs$11
+});
+var runs$11 = async (_c, next) => next();
+var comment_pr_autofix_result_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: commentPrAutofixResultAction
+});
+//#endregion
+//#region src/workflows/dev-doctor.ts
+var dev_doctor_exports = /* @__PURE__ */ __exportAll({
+	default: () => dev_doctor_default,
+	runs: () => runs$10
+});
+var runs$10 = async (_c, next) => next();
+var dev_doctor_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: devDoctorRunAction
+});
+//#endregion
+//#region src/workflows/fix-pr-ci-failure.ts
+var fix_pr_ci_failure_exports = /* @__PURE__ */ __exportAll({
+	default: () => fix_pr_ci_failure_default,
+	runs: () => runs$9
+});
+var runs$9 = async (_c, next) => next();
+var fix_pr_ci_failure_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: fixPrCiFailureAction
+});
+//#endregion
+//#region src/workflows/fix-pr-review-feedback.ts
+var fix_pr_review_feedback_exports = /* @__PURE__ */ __exportAll({
+	default: () => fix_pr_review_feedback_default,
+	runs: () => runs$8
+});
+var runs$8 = async (_c, next) => next();
+var fix_pr_review_feedback_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: fixPrReviewFeedbackAction
+});
+//#endregion
+//#region src/workflows/handoff_to_kilo.ts
+var handoff_to_kilo_exports = /* @__PURE__ */ __exportAll({
+	default: () => handoff_to_kilo_default,
+	runs: () => runs$7
+});
+var runs$7 = async (_c, next) => next();
+var handoff_to_kilo_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: kiloTaskStartAction
+});
+//#endregion
+//#region src/workflows/promote_kilo_result.ts
+var promote_kilo_result_exports = /* @__PURE__ */ __exportAll({
+	default: () => promote_kilo_result_default,
+	runs: () => runs$6
+});
+var runs$6 = async (_c, next) => next();
+var promote_kilo_result_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: promoteKiloResultAction
+});
+//#endregion
+//#region src/workflows/reconcile_kilo_task.ts
+var reconcile_kilo_task_exports = /* @__PURE__ */ __exportAll({
+	default: () => reconcile_kilo_task_default,
+	runs: () => runs$5
+});
+var runs$5 = async (_c, next) => next();
+var reconcile_kilo_task_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: kiloTaskReconcileAction
+});
+//#endregion
+//#region src/workflows/review_kilo_result.ts
+var review_kilo_result_exports = /* @__PURE__ */ __exportAll({
+	default: () => review_kilo_result_default,
+	runs: () => runs$4
+});
+var runs$4 = async (_c, next) => next();
+var review_kilo_result_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: reviewKiloResultAction
+});
+//#endregion
+//#region src/workflows/summarize_kilo_session.ts
+var summarize_kilo_session_exports = /* @__PURE__ */ __exportAll({
+	default: () => summarize_kilo_session_default,
+	runs: () => runs$3
+});
+var nonEmptyStringSchema = v.pipe(v.string(), v.minLength(1));
+var runs$3 = async (_c, next) => next();
+var summarize_kilo_session_default = defineWorkflow({
+	agent: display_assistant_default,
+	input: v.object({
+		taskId: v.optional(nonEmptyStringSchema),
+		sessionId: v.optional(nonEmptyStringSchema),
+		titleQuery: v.optional(nonEmptyStringSchema)
+	}),
+	async run({ input }) {
+		const result = await summarizeKiloSession(input);
+		return JSON.parse(JSON.stringify(result));
+	}
+});
+//#endregion
+//#region src/workflows/verify-pr-worktree.ts
+var verify_pr_worktree_exports = /* @__PURE__ */ __exportAll({
+	default: () => verify_pr_worktree_default,
+	runs: () => runs$2
+});
+var runs$2 = async (_c, next) => next();
+var verify_pr_worktree_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: verifyPrWorktreeAction
+});
+//#endregion
+//#region src/workflows/verify_kilo_result.ts
+var verify_kilo_result_exports = /* @__PURE__ */ __exportAll({
+	default: () => verify_kilo_result_default,
+	runs: () => runs$1
+});
+var runs$1 = async (_c, next) => next();
+var verify_kilo_result_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: verifyKiloResultAction
+});
+//#endregion
+//#region src/workflows/watch-pr.ts
+var watch_pr_exports = /* @__PURE__ */ __exportAll({
+	default: () => watch_pr_default,
+	runs: () => runs
+});
+var runs = async (_c, next) => next();
+var watch_pr_default = defineWorkflow({
+	agent: display_assistant_default,
+	action: watchPrAddAction
+});
+//#endregion
+//#region src/db.ts
+var flueLongPollGraceMs = 5e3;
+var paths = runtimePaths();
+ensureRuntimeHomeSync(paths);
+var db_default = delayClose(sqlite(paths.flueDatabase), flueLongPollGraceMs);
+function delayClose(adapter, delayMs) {
+	let closeTimer;
+	function cancelPendingClose() {
+		if (!closeTimer) return;
+		clearTimeout(closeTimer);
+		closeTimer = void 0;
+	}
+	return {
+		async migrate() {
+			cancelPendingClose();
+			await adapter.migrate?.();
+		},
+		async connect() {
+			cancelPendingClose();
+			return adapter.connect();
+		},
+		close() {
+			cancelPendingClose();
+			closeTimer = setTimeout(() => {
+				closeTimer = void 0;
+				adapter.close?.();
+			}, delayMs);
+			closeTimer.unref?.();
+		}
+	};
+}
+//#endregion
+//#region .flue-vite/_entry_server.ts
+function normalizeBuiltModules(agentModules, workflowModules, channelModules = {}) {
+	const agents = [];
+	const workflows = [];
+	const channelHandlers = {};
+	for (const [name, mod] of Object.entries(agentModules)) {
+		if (!mod.default || mod.default.__flueAgentDefinition !== true || typeof mod.default.initialize !== "function") throw new Error("[flue] Agent \"" + name + "\" must default-export defineAgent(...).");
+		if (mod.route !== void 0 && typeof mod.route !== "function") throw new Error("[flue] Agent \"" + name + "\" route export must be a callable Hono middleware value.");
+		if (mod.attachments !== void 0 && typeof mod.attachments !== "function") throw new Error("[flue] Agent \"" + name + "\" attachments export must be a callable Hono middleware value.");
+		if (mod.description !== void 0 && (typeof mod.description !== "string" || mod.description.trim().length === 0)) throw new Error("[flue] Agent \"" + name + "\" description export must be a non-empty string.");
+		const previous = agents.find((agent) => agent.definition === mod.default);
+		if (previous) throw new Error("[flue] Agents \"" + previous.name + "\" and \"" + name + "\" default-export the same agent definition value. Use distinct defineAgent(...) values for dispatchable agent modules.");
+		const agent = {
+			name,
+			definition: mod.default
+		};
+		if (mod.description !== void 0) agent.description = mod.description;
+		if (typeof mod.route === "function") agent.route = mod.route;
+		if (typeof mod.attachments === "function") agent.attachments = mod.attachments;
+		agents.push(agent);
+	}
+	for (const [name, mod] of Object.entries(workflowModules)) {
+		assertWorkflowDefinition(mod.default, name);
+		if (mod.route !== void 0 && typeof mod.route !== "function") throw new Error("[flue] Workflow \"" + name + "\" route export must be a callable Hono middleware value.");
+		if (mod.runs !== void 0 && typeof mod.runs !== "function") throw new Error("[flue] Workflow \"" + name + "\" runs export must be a callable Hono middleware value.");
+		const previous = workflows.find((workflow) => workflow.definition === mod.default);
+		if (previous) throw new Error("[flue] Workflows \"" + previous.name + "\" and \"" + name + "\" default-export the same workflow definition value. Use distinct defineWorkflow(...) values for workflow modules.");
+		const workflow = {
+			name,
+			definition: mod.default
+		};
+		if (typeof mod.route === "function") workflow.route = mod.route;
+		if (typeof mod.runs === "function") workflow.runs = mod.runs;
+		workflows.push(workflow);
+	}
+	for (const [name, mod] of Object.entries(channelModules)) {
+		const channel = mod.channel;
+		if (!channel || typeof channel !== "object" || Array.isArray(channel)) throw new Error("[flue] Channel \"" + name + "\" must export a created channel as the named \"channel\" binding.");
+		if (!Array.isArray(channel.routes) || channel.routes.length === 0) throw new Error("[flue] Channel \"" + name + "\" must declare at least one route.");
+		const routes = {};
+		for (const route of channel.routes) {
+			if (!route || typeof route !== "object" || Array.isArray(route)) throw new Error("[flue] Channel \"" + name + "\" contains an invalid route declaration.");
+			if (typeof route.method !== "string" || !/^[A-Z]+$/.test(route.method)) throw new Error("[flue] Channel \"" + name + "\" route method must contain only uppercase ASCII letters.");
+			if (typeof route.path !== "string" || route.path.length < 2 || !route.path.startsWith("/") || route.path.startsWith("//") || route.path.includes("?") || route.path.includes("#")) throw new Error("[flue] Channel \"" + name + "\" route path must be a non-empty absolute suffix without a query or fragment.");
+			if (route.path.split("/").some((segment) => segment === "." || segment === "..")) throw new Error("[flue] Channel \"" + name + "\" route path must remain beneath its channel namespace.");
+			if (typeof route.handler !== "function") throw new Error("[flue] Channel \"" + name + "\" route handler must be callable.");
+			const key = route.method + " " + route.path;
+			if (routes[key] !== void 0) throw new Error("[flue] Channel \"" + name + "\" declares duplicate route \"" + key + "\".");
+			routes[key] = route.handler;
+		}
+		channelHandlers[name] = routes;
+	}
+	return {
+		agents,
+		workflows,
+		channelHandlers
+	};
+}
+var { agents, workflows, channelHandlers } = normalizeBuiltModules({
+	"busywork-workflow": busywork_workflow_exports,
+	"display-assistant": display_assistant_exports,
+	"pr-review-assistant": pr_review_assistant_exports,
+	"scheduler-workflow": scheduler_workflow_exports
+}, {
+	"briefing": briefing_exports,
+	"command-run": command_run_exports,
+	"comment-pr-autofix-result": comment_pr_autofix_result_exports,
+	"curate_learning_store": curate_learning_store_exports,
+	"dev-doctor": dev_doctor_exports,
+	"fix-pr-ci-failure": fix_pr_ci_failure_exports,
+	"fix-pr-ci": fix_pr_ci_exports,
+	"fix-pr-review-feedback": fix_pr_review_feedback_exports,
+	"handoff_to_kilo": handoff_to_kilo_exports,
+	"prepare-pr-worktree": prepare_pr_worktree_exports,
+	"promote_kilo_result": promote_kilo_result_exports,
+	"push-pr-autofix": push_pr_autofix_exports,
+	"reconcile_kilo_task": reconcile_kilo_task_exports,
+	"review-pr-for-human": review_pr_for_human_exports,
+	"review_conversation_for_learning": review_conversation_for_learning_exports,
+	"review_kilo_result": review_kilo_result_exports,
+	"review_pr_batch_for_learning": review_pr_batch_for_learning_exports,
+	"scheduled-agent-instruction": scheduled_agent_instruction_exports,
+	"scheduler-tick": scheduler_tick_exports,
+	"summarize_kilo_session": summarize_kilo_session_exports,
+	"triage-pr-event": triage_pr_event_exports,
+	"verify-pr-worktree": verify_pr_worktree_exports,
+	"verify-then-push-pr-autofix": verify_then_push_pr_autofix_exports,
+	"verify_kilo_result": verify_kilo_result_exports,
+	"watch-pr": watch_pr_exports
+}, {});
+/**
+* Create an empty in-memory sandbox (default).
+* Uses InMemoryFs (no real filesystem access) with sensible defaults:
+* cwd = /home/user, /tmp exists, /bin and /usr/bin exist.
+*/
+async function createDefaultEnv() {
+	const fs = new InMemoryFs();
+	return bashFactoryToSessionEnv(() => new Bash({
+		fs,
+		network: { dangerouslyAllowFullInternetAccess: true }
+	}));
+}
+async function loadFlueNodeApplication(options = {}) {
+	const runtimeEnv = options.env ?? process.env;
+	const isLocalMode = options.local === true;
+	const outputContext = new AsyncLocalStorage();
+	const originalConsole = /* @__PURE__ */ new Map();
+	let outputRestored = false;
+	const restoreOutput = () => {
+		if (outputRestored) return;
+		outputRestored = true;
+		for (const [method, original] of originalConsole) console[method] = original;
+	};
+	if (options.onOutput) for (const method of [
+		"log",
+		"info",
+		"debug",
+		"warn",
+		"error"
+	]) {
+		const original = console[method];
+		originalConsole.set(method, original);
+		console[method] = (...args) => {
+			if (!outputContext.getStore()) return original.apply(console, args);
+			outputContext.exit(() => options.onOutput({
+				stream: method === "warn" || method === "error" ? "stderr" : "stdout",
+				line: format(...args)
+			}));
+		};
+	}
+	const runInRuntime = (fn) => outputContext.run(true, fn);
+	const instrumentationOwner = createInstrumentationOwner();
+	let devLifecycle;
+	let persistenceAdapter;
+	let agentCoordinator;
+	try {
+		return await runInRuntime(() => runWithInstrumentationOwner(instrumentationOwner, async () => {
+			devLifecycle = isLocalMode && options.internalDevLogs === true ? installDevLifecycleLogger() : void 0;
+			const { default: userApp } = await import("./assets/app-CnXGMuTl.js");
+			if (!db_default || typeof db_default.connect !== "function") throw new Error("[flue] db.ts must default-export a PersistenceAdapter with a connect() method.");
+			let executionStore;
+			let runStore;
+			let eventStreamStore;
+			let conversationStreamStore;
+			let attachmentStore;
+			try {
+				if (db_default.migrate) await db_default.migrate();
+				const stores = await db_default.connect();
+				if (!stores || typeof stores !== "object") throw new Error("connect() must return { executionStore, runStore, eventStreamStore }.");
+				({executionStore, runStore, eventStreamStore, conversationStreamStore, attachmentStore} = stores);
+				if (!executionStore || typeof executionStore.submissions?.getSubmission !== "function") throw new Error("connect() must return an executionStore with submissions.");
+				if (!runStore || typeof runStore.createRun !== "function" || typeof runStore.listRuns !== "function") throw new Error("connect() must return a runStore.");
+				if (!eventStreamStore || typeof eventStreamStore.appendEvent !== "function" || typeof eventStreamStore.readEvents !== "function") throw new Error("connect() must return an eventStreamStore.");
+				if (!conversationStreamStore || typeof conversationStreamStore.append !== "function" || typeof conversationStreamStore.acquireProducer !== "function") throw new Error("connect() must return a conversationStreamStore.");
+				if (!attachmentStore || typeof attachmentStore.put !== "function" || typeof attachmentStore.get !== "function") throw new Error("connect() must return an attachmentStore.");
+			} catch (error) {
+				throw new Error("[flue] Failed to initialize persistence from db.ts: " + (error instanceof Error ? error.message : error), { cause: error });
+			}
+			persistenceAdapter = db_default;
+			const activityGate = createRuntimeActivityGate();
+			agentCoordinator = createNodeAgentCoordinator({
+				submissions: executionStore.submissions,
+				agents,
+				createContext: createAgentContextForRequest,
+				conversationStreamStore,
+				attachmentStore,
+				onInteractionStart: devLifecycle?.onAgentInteractionStart,
+				activityGate
+			});
+			const dispatchQueue = createNodeDispatchQueue(agentCoordinator);
+			function createAgentContextForRequest({ id, agentName, request, initialEventIndex, dispatchId }) {
+				return createFlueContext({
+					id,
+					agentName,
+					dispatchId,
+					initialEventIndex,
+					env: runtimeEnv,
+					req: request,
+					agentConfig: { resolveModel },
+					createDefaultEnv,
+					submissionStore: executionStore.submissions
+				});
+			}
+			function createWorkflowContextForRequest({ runId, request, initialEventIndex }) {
+				return createFlueContext({
+					id: runId,
+					runId,
+					initialEventIndex,
+					env: runtimeEnv,
+					req: request,
+					agentConfig: { resolveModel },
+					createDefaultEnv,
+					submissionStore: executionStore.submissions
+				});
+			}
+			configureFlueRuntime({
+				target: "node",
+				devMode: isLocalMode,
+				temporaryLocalExposure: false,
+				agents,
+				workflows,
+				createAgentAdmission: (agentName, instanceId) => agentCoordinator.createAdmission(agentName, instanceId),
+				abortAgentInstance: (agentName, instanceId) => agentCoordinator.abortInstance(agentName, instanceId),
+				dispatchQueue,
+				activityGate,
+				admitWorkflow: ({ workflowName, input }) => {
+					const workflow = workflows.find((record) => record.name === workflowName)?.definition;
+					if (!workflow) throw new Error("[flue] Internal workflow admission target is not registered.");
+					return admitDetachedWorkflow({
+						workflowName,
+						workflow,
+						input,
+						request: new Request("https://flue.invalid/_internal/workflows/" + encodeURIComponent(workflowName), { method: "POST" }),
+						createContext: createWorkflowContextForRequest,
+						runStore,
+						eventStreamStore,
+						activityGate
+					});
+				},
+				channelHandlers,
+				createWorkflowContext: createWorkflowContextForRequest,
+				runStore,
+				eventStreamStore,
+				conversationStreamStore,
+				attachmentStore
+			});
+			try {
+				await runInRuntime(() => agentCoordinator.reconcileSubmissions());
+			} catch (error) {
+				runInRuntime(() => console.error("[flue] Startup submission reconciliation failed:", error));
+			}
+			const flueApp = userApp;
+			if (!flueApp || typeof flueApp.fetch !== "function") throw new Error("[flue] app.ts default export must be a Hono app or an object with a fetch(request) method.");
+			let disposing;
+			return {
+				fetch: (request, env) => runInRuntime(() => flueApp.fetch(request, env)),
+				enterActivity() {
+					return activityGate.enter();
+				},
+				pauseAdmissions() {
+					activityGate.pause();
+				},
+				waitForIdle() {
+					return activityGate.waitForIdle();
+				},
+				async stop(timeoutMs = 3e4) {
+					if (disposing) return disposing;
+					disposing = runInRuntime(async () => {
+						const errors = [];
+						try {
+							await agentCoordinator.shutdown(timeoutMs);
+						} catch (error) {
+							errors.push(error);
+						}
+						try {
+							await instrumentationOwner.dispose();
+						} catch (error) {
+							errors.push(error);
+						}
+						try {
+							if (persistenceAdapter.close) await persistenceAdapter.close();
+						} catch (error) {
+							errors.push(error);
+						}
+						devLifecycle?.dispose();
+						restoreOutput();
+						if (errors.length === 1) throw errors[0];
+						if (errors.length > 1) throw new AggregateError(errors, "[flue] Node application shutdown failed.");
+					});
+					return disposing;
+				},
+				closeSync() {
+					devLifecycle?.dispose();
+					restoreOutput();
+				}
+			};
+		}));
+	} catch (error) {
+		const cleanupErrors = [];
+		try {
+			if (agentCoordinator) await agentCoordinator.shutdown(3e4);
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+		}
+		try {
+			if (persistenceAdapter?.close) await persistenceAdapter.close();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+		}
+		try {
+			await instrumentationOwner.dispose();
+		} catch (cleanupError) {
+			cleanupErrors.push(cleanupError);
+		}
+		devLifecycle?.dispose();
+		restoreOutput();
+		if (cleanupErrors.length) throw new AggregateError([error, ...cleanupErrors], "[flue] Node application startup failed.");
+		throw error;
+	}
+}
+async function startFlueNodeServer(options = {}) {
+	const application = await loadFlueNodeApplication(options);
+	const port = options.port ?? 3e3;
+	let resolveReady;
+	let rejectReady;
+	const ready = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const server = serve({
+		fetch: application.fetch,
+		port,
+		...options.hostname ? { hostname: options.hostname } : {},
+		serverOptions: { requestTimeout: 0 }
+	}, () => {
+		if (!options.quiet) console.log("[flue] Server listening on http://localhost:" + port);
+		options.onReady?.();
+		resolveReady();
+	});
+	const onServerError = (error) => rejectReady(error);
+	const onAbort = () => {
+		server.closeAllConnections();
+		server.close();
+		rejectReady(options.signal?.reason ?? new DOMException("Aborted", "AbortError"));
+	};
+	server.once("error", onServerError);
+	options.signal?.addEventListener("abort", onAbort, { once: true });
+	if (options.signal?.aborted) onAbort();
+	try {
+		await ready;
+	} catch (error) {
+		server.closeAllConnections();
+		server.close();
+		await application.stop();
+		throw error;
+	} finally {
+		server.off("error", onServerError);
+		options.signal?.removeEventListener("abort", onAbort);
+	}
+	let stopping;
+	return {
+		async stop() {
+			if (stopping) return stopping;
+			stopping = (async () => {
+				const errors = [];
+				const httpClosed = new Promise((resolve) => server.close((error) => {
+					if (error) errors.push(error);
+					resolve();
+				}));
+				try {
+					await application.stop();
+				} catch (error) {
+					errors.push(error);
+				}
+				server.closeAllConnections();
+				await httpClosed;
+				if (errors.length === 1) throw errors[0];
+				if (errors.length > 1) throw new AggregateError(errors, "[flue] Node server shutdown failed.");
+			})();
+			return stopping;
+		},
+		closeSync() {
+			server.closeAllConnections();
+			server.close();
+			application.closeSync();
+		}
+	};
+}
+var lifecycle = await startFlueNodeServer({ port: parseInt(process.env.PORT || "3000", 10) });
+async function stop(exitCode) {
+	setTimeout(() => {
+		console.error("[flue] Shutdown timed out, exiting.");
+		process.exit(exitCode);
+	}, 6e4).unref();
+	await lifecycle.stop();
+	process.exit(exitCode);
+}
+process.on("SIGINT", () => {
+	stop(130);
+});
+process.on("SIGTERM", () => {
+	stop(143);
+});
+process.on("disconnect", () => {
+	stop(0);
+});
+//#endregion
+export { loadFlueNodeApplication, startFlueNodeServer };
+
+//# sourceMappingURL=server.mjs.map