@helioslx/core 0.2.0

package/dist/http.js

@@ -0,0 +1,670 @@
+import { a as SacnValidationError, i as SacnLifecycleError, n as PersistenceError, o as TransportError, t as DependencyUnavailableError } from "./validation-BdsVeyAE.js";
+import { Elysia, t } from "elysia";
+import { openapi } from "@elysiajs/openapi";
+import { node } from "@elysiajs/node";
+//#region src/http.ts
+const outputParamsSchema = t.Object({
+	universe: t.String({ pattern: "^-?\\d+$" }),
+	priority: t.String({ pattern: "^-?\\d+$" })
+});
+const frameValuesSchema = t.Array(t.Integer({
+	minimum: 0,
+	maximum: 255
+}), {
+	minItems: 512,
+	maxItems: 512
+});
+const outputOptionsSchema = {
+	cid: t.Optional(t.String()),
+	idleFps: t.Optional(t.Number({
+		exclusiveMinimum: 0,
+		maximum: 1e3
+	})),
+	sourceName: t.Optional(t.String({
+		minLength: 1,
+		maxLength: 64
+	}))
+};
+const frameBodySchema = t.Object({
+	values: frameValuesSchema,
+	durationMs: t.Optional(t.Number({ minimum: 0 })),
+	...outputOptionsSchema
+});
+const upsertBodySchema = t.Object({
+	initialValues: t.Optional(frameValuesSchema),
+	values: t.Optional(frameValuesSchema),
+	durationMs: t.Optional(t.Number({ minimum: 0 })),
+	...outputOptionsSchema
+});
+const channelWritesSchema = t.Array(t.Object({
+	channel: t.Integer({
+		minimum: 1,
+		maximum: 512
+	}),
+	value: t.Integer({
+		minimum: 0,
+		maximum: 255
+	}),
+	durationMs: t.Optional(t.Number({ minimum: 0 }))
+}), { minItems: 1 });
+const channelsBodySchema = t.Union([t.Object({
+	channels: t.Union([channelWritesSchema, t.Record(t.String(), t.Integer({
+		minimum: 0,
+		maximum: 255
+	}))]),
+	durationMs: t.Optional(t.Number({ minimum: 0 })),
+	...outputOptionsSchema
+}), t.Object({
+	changes: channelWritesSchema,
+	durationMs: t.Optional(t.Number({ minimum: 0 })),
+	...outputOptionsSchema
+})]);
+const outputSnapshotSchema = t.Object({
+	activeTransitions: t.Integer({ minimum: 0 }),
+	cid: t.String(),
+	current: frameValuesSchema,
+	dirty: t.Boolean(),
+	frameMode: t.Union([t.Literal("active"), t.Literal("idle")]),
+	idleFps: t.Number(),
+	lastError: t.Union([t.String(), t.Null()]),
+	lastSent: frameValuesSchema,
+	lastSentAt: t.Union([t.Number(), t.Null()]),
+	nextDueAt: t.Number(),
+	priority: t.Integer(),
+	sequence: t.Integer(),
+	sourceName: t.Union([t.String(), t.Null()]),
+	target: frameValuesSchema,
+	universe: t.Integer(),
+	updatedAt: t.Number()
+});
+const errorSchema = t.Object({ error: t.String() });
+const viewerStateSchema = t.Object({ universes: t.Array(t.Integer({
+	minimum: 1,
+	maximum: 63999
+})) });
+const engineTelemetrySchema = t.Object({
+	closed: t.Boolean(),
+	running: t.Boolean(),
+	outputCount: t.Integer({ minimum: 0 }),
+	outputs: t.Array(outputSnapshotSchema),
+	loopIterations: t.Integer({ minimum: 0 }),
+	lastLoopStartedAt: t.Union([t.Number(), t.Null()]),
+	lastLoopCompletedAt: t.Union([t.Number(), t.Null()]),
+	lastLoopDurationMs: t.Union([t.Number(), t.Null()]),
+	transport: t.Object({
+		sendAttempts: t.Integer({ minimum: 0 }),
+		sendFailures: t.Integer({ minimum: 0 }),
+		sendRetries: t.Integer({ minimum: 0 }),
+		sendSuccesses: t.Integer({ minimum: 0 }),
+		sendTimeouts: t.Integer({ minimum: 0 })
+	})
+});
+const viewerTelemetrySchema = t.Object({
+	droppedUpdates: t.Integer({ minimum: 0 }),
+	packetsReceived: t.Integer({ minimum: 0 }),
+	selectedUniverses: t.Array(t.Integer()),
+	streamCount: t.Integer({ minimum: 0 })
+});
+const viewerUniverseParamsSchema = t.Object({ universe: t.String({ pattern: "^-?\\d+$" }) });
+const errorResponseDocument = (description) => ({
+	description,
+	content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } }
+});
+const outputResponseDocument = {
+	200: {
+		description: "Output snapshot",
+		content: { "application/json": { schema: { $ref: "#/components/schemas/OutputSnapshot" } } }
+	},
+	400: errorResponseDocument("Invalid request"),
+	409: errorResponseDocument("Lifecycle conflict"),
+	503: errorResponseDocument("Transport or persistence unavailable")
+};
+const outputLookupResponseDocument = {
+	...outputResponseDocument,
+	404: errorResponseDocument("Output not found")
+};
+const clearResponseDocument = {
+	200: {
+		description: "Output cleared",
+		content: { "application/json": { schema: {
+			type: "object",
+			required: ["ok"],
+			properties: { ok: {
+				type: "boolean",
+				const: true
+			} }
+		} } }
+	},
+	400: errorResponseDocument("Invalid request"),
+	404: errorResponseDocument("Output not found"),
+	409: errorResponseDocument("Lifecycle conflict"),
+	503: errorResponseDocument("Transport or persistence unavailable")
+};
+const componentResponse = (schema, description) => ({
+	200: {
+		description,
+		content: { "application/json": { schema: { $ref: `#/components/schemas/${schema}` } } }
+	},
+	400: errorResponseDocument("Invalid request"),
+	409: errorResponseDocument("Lifecycle conflict"),
+	503: errorResponseDocument("Dependency unavailable")
+});
+const integerParam = (value, label) => {
+	if (!/^-?\d+$/.test(value)) throw new SacnValidationError(`${label} must be an integer.`, label === "Universe" ? "INVALID_UNIVERSE" : "INVALID_PRIORITY");
+	return Number(value);
+};
+const addressOf = (params) => ({
+	universe: integerParam(params.universe, "Universe"),
+	priority: integerParam(params.priority, "Priority")
+});
+const bodyObject = (body) => {
+	if (!body || typeof body !== "object" || Array.isArray(body)) throw new SacnValidationError("Request body must be an object.", "INVALID_FRAME");
+	return body;
+};
+const messageOf = (error) => error instanceof Error ? error.message : "Internal server error.";
+const statusOf = (error) => {
+	if (error instanceof SacnValidationError) return 400;
+	if (error instanceof SacnLifecycleError) return 409;
+	if (error instanceof DependencyUnavailableError || error instanceof PersistenceError || error instanceof TransportError) return 503;
+	return 500;
+};
+const fail = (set, error) => {
+	set.status = statusOf(error);
+	return { error: messageOf(error) };
+};
+const deprecated = (set, successor, sunset) => {
+	set.headers.deprecation = "true";
+	set.headers.link = `<${successor}>; rel="successor-version"`;
+	set.headers.sunset = sunset;
+};
+const channelsFrom = (body) => {
+	const record = bodyObject(body);
+	const sharedDuration = typeof record.durationMs === "number" ? record.durationMs : void 0;
+	const value = record.channels ?? record.changes;
+	const options = {
+		...sharedDuration === void 0 ? {} : { durationMs: sharedDuration },
+		...record.idleFps === void 0 ? {} : { idleFps: record.idleFps },
+		...record.sourceName === void 0 ? {} : { sourceName: record.sourceName },
+		...record.cid === void 0 ? {} : { cid: record.cid }
+	};
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		const values = {};
+		for (const [key, channelValue] of Object.entries(value)) values[Number(key)] = channelValue;
+		if (sharedDuration !== void 0 && sharedDuration > 0) return {
+			mode: "fade",
+			values,
+			...options
+		};
+		return {
+			mode: "set",
+			values,
+			...options
+		};
+	}
+	if (!Array.isArray(value)) throw new SacnValidationError("Body must contain a channels array or map.", "INVALID_CHANNEL");
+	const writes = value.map((item) => {
+		const change = bodyObject(item);
+		const durationMs = typeof change.durationMs === "number" ? change.durationMs : void 0;
+		return {
+			channel: change.channel,
+			value: change.value,
+			...durationMs === void 0 ? {} : { durationMs }
+		};
+	});
+	if (writes.some((write) => write.durationMs !== void 0 && write.durationMs > 0)) return {
+		mode: "transition",
+		writes: writes.map((write) => ({
+			channel: write.channel,
+			value: write.value,
+			durationMs: write.durationMs ?? sharedDuration ?? 0
+		})),
+		...options
+	};
+	const values = {};
+	for (const write of writes) values[write.channel] = write.value;
+	if (sharedDuration !== void 0 && sharedDuration > 0) return {
+		mode: "fade",
+		values,
+		...options
+	};
+	return {
+		mode: "set",
+		values,
+		...options
+	};
+};
+const frameFrom = (body) => {
+	const record = bodyObject(body);
+	const values = record.values ?? record.initialValues;
+	if (!Array.isArray(values) && !(values instanceof Uint8Array)) throw new SacnValidationError("Body must contain a values array.", "INVALID_FRAME");
+	const durationMs = record.durationMs;
+	return {
+		values,
+		...durationMs === void 0 ? {} : { durationMs },
+		...record.idleFps === void 0 ? {} : { idleFps: record.idleFps },
+		...record.sourceName === void 0 ? {} : { sourceName: record.sourceName },
+		...record.cid === void 0 ? {} : { cid: record.cid }
+	};
+};
+const universeOf = (source, params, extras = {}) => {
+	const address = addressOf(params);
+	return source.universe(address.universe, {
+		priority: address.priority,
+		...extras
+	});
+};
+const applyChannels = async (universe, parsed) => {
+	if (parsed.mode === "fade" && parsed.values) return universe.fadeChannels(parsed.values, { durationMs: parsed.durationMs ?? 0 });
+	if (parsed.mode === "transition" && parsed.writes) return universe.transition(parsed.writes);
+	if (parsed.values) return universe.setChannels(parsed.values);
+	throw new SacnValidationError("Body must contain channel values.", "INVALID_CHANNEL");
+};
+/**
+* Creates an unbound Elysia route plugin. CORS and server binding deliberately
+* remain the host application's responsibility.
+*/
+const createSacnHttpAdapter = (options) => {
+	const prefix = options.prefix ?? "/sacn";
+	const sunset = options.sunset ?? "Wed, 01 Jul 2027 00:00:00 GMT";
+	const maxWebSocketClients = options.maxWebSocketClients ?? 64;
+	const webSocketQueueCapacity = options.webSocketQueueCapacity ?? 32;
+	if (!Number.isInteger(maxWebSocketClients) || maxWebSocketClients < 1) throw new SacnValidationError("Maximum WebSocket clients must be a positive integer.", "INVALID_FRAME");
+	if (!Number.isInteger(webSocketQueueCapacity) || webSocketQueueCapacity < 1) throw new SacnValidationError("WebSocket queue capacity must be a positive integer.", "INVALID_FRAME");
+	const clients = /* @__PURE__ */ new Set();
+	const closeClient = (client) => {
+		clients.delete(client);
+		client.pending.clear();
+		try {
+			client.socket.close();
+		} catch {}
+	};
+	const flushClient = (client) => {
+		client.scheduled = false;
+		const packets = [...client.pending.values()];
+		client.pending.clear();
+		for (const packet of packets) try {
+			const status = client.socket.send({
+				packet,
+				type: "viewer-packet"
+			});
+			if (typeof status === "number" && status <= 0) {
+				closeClient(client);
+				return;
+			}
+		} catch {
+			closeClient(client);
+			return;
+		}
+	};
+	const dispatchViewerPacket = (packet) => {
+		try {
+			options.onViewerPacket?.(packet);
+		} catch {}
+		for (const client of clients) {
+			if (client.pending.has(packet.universe)) client.pending.delete(packet.universe);
+			else if (client.pending.size >= webSocketQueueCapacity) {
+				const oldestUniverse = client.pending.keys().next().value;
+				if (oldestUniverse !== void 0) client.pending.delete(oldestUniverse);
+			}
+			client.pending.set(packet.universe, packet);
+			if (!client.scheduled) {
+				client.scheduled = true;
+				queueMicrotask(() => flushClient(client));
+			}
+		}
+	};
+	const unsubscribePackets = options.viewer ? options.viewer.subscribe(dispatchViewerPacket) : void 0;
+	const app = new Elysia({
+		adapter: node(),
+		prefix
+	}).use(openapi({
+		path: options.openapiPath ?? "/openapi",
+		documentation: {
+			components: { schemas: {
+				Error: errorSchema,
+				EngineTelemetry: engineTelemetrySchema,
+				OutputSnapshot: outputSnapshotSchema,
+				ViewerState: viewerStateSchema,
+				ViewerTelemetry: viewerTelemetrySchema
+			} },
+			info: {
+				title: "@helioslx/core sACN API",
+				version: "0.1.0"
+			}
+		}
+	})).onBeforeHandle(async ({ request, set }) => {
+		try {
+			const result = await options.auth?.({ request });
+			if (result instanceof Response) return result;
+			if (result === false) {
+				set.status = 401;
+				return { error: "Unauthorized." };
+			}
+		} catch (error) {
+			return fail(set, error);
+		}
+	}).onError(({ code, error, set }) => {
+		if (code === "VALIDATION") {
+			set.status = 400;
+			return { error: error.message };
+		}
+	}).onStop(() => {
+		unsubscribePackets?.();
+		clients.clear();
+	}).get("/health/live", () => ({ status: "ok" }), { response: { 200: t.Object({ status: t.Literal("ok") }) } }).get("/health/ready", ({ set }) => {
+		const telemetry = options.source.getTelemetry();
+		if (!telemetry.running || telemetry.closed) {
+			set.status = 503;
+			return { status: "not-ready" };
+		}
+		return { status: "ready" };
+	}, { response: {
+		200: t.Object({ status: t.Literal("ready") }),
+		503: t.Object({ status: t.Literal("not-ready") })
+	} }).get("/universes", async ({ set }) => {
+		try {
+			return await options.source.listUniverses();
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, { detail: { responses: {
+		200: {
+			description: "Active outputs",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: { $ref: "#/components/schemas/OutputSnapshot" }
+			} } }
+		},
+		409: errorResponseDocument("Lifecycle conflict"),
+		503: errorResponseDocument("Persistence unavailable")
+	} } }).get("/engine/telemetry", () => options.source.getTelemetry(), { detail: { responses: componentResponse("EngineTelemetry", "Engine telemetry") } }).get("/universes/:universe/priorities/:priority", async ({ params, set }) => {
+		try {
+			const output = await universeOf(options.source, params).get();
+			if (!output) {
+				set.status = 404;
+				return { error: "Output not found." };
+			}
+			return output;
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: { responses: outputLookupResponseDocument },
+		params: outputParamsSchema
+	}).put("/universes/:universe/priorities/:priority", async ({ body, params, set }) => {
+		try {
+			const record = bodyObject(body);
+			const frame = frameFrom({
+				...record,
+				values: record.initialValues ?? record.values ?? Array.from({ length: 512 }, () => 0)
+			});
+			const universe = universeOf(options.source, params, {
+				...frame.cid === void 0 ? {} : { cid: frame.cid },
+				...frame.idleFps === void 0 ? {} : { idleFps: frame.idleFps },
+				...frame.sourceName === void 0 ? {} : { sourceName: frame.sourceName }
+			});
+			const existing = await universe.get();
+			const supplied = record.initialValues ?? record.values;
+			const values = Array.isArray(supplied) || supplied instanceof Uint8Array ? supplied : existing?.target ?? Array.from({ length: 512 }, () => 0);
+			return await universe.write(values, { ...frame.durationMs === void 0 ? {} : { durationMs: frame.durationMs } });
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: upsertBodySchema,
+		detail: { responses: outputResponseDocument },
+		params: outputParamsSchema
+	}).post("/universes/:universe/priorities/:priority/channels", async ({ body, params, set }) => {
+		try {
+			const parsed = channelsFrom(body);
+			const universe = universeOf(options.source, params, {
+				...parsed.cid === void 0 ? {} : { cid: parsed.cid },
+				...parsed.idleFps === void 0 ? {} : { idleFps: parsed.idleFps },
+				...parsed.sourceName === void 0 ? {} : { sourceName: parsed.sourceName }
+			});
+			return await applyChannels(universe, parsed);
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: channelsBodySchema,
+		detail: { responses: outputResponseDocument },
+		params: outputParamsSchema
+	}).post("/universes/:universe/priorities/:priority/frame", async ({ body, params, set }) => {
+		try {
+			const frame = frameFrom(body);
+			return await universeOf(options.source, params, {
+				...frame.cid === void 0 ? {} : { cid: frame.cid },
+				...frame.idleFps === void 0 ? {} : { idleFps: frame.idleFps },
+				...frame.sourceName === void 0 ? {} : { sourceName: frame.sourceName }
+			}).write(frame.values, { ...frame.durationMs === void 0 ? {} : { durationMs: frame.durationMs } });
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: frameBodySchema,
+		detail: { responses: outputResponseDocument },
+		params: outputParamsSchema
+	}).delete("/universes/:universe/priorities/:priority", async ({ params, set }) => {
+		try {
+			if (!await universeOf(options.source, params).clear()) {
+				set.status = 404;
+				return { error: "Output not found." };
+			}
+			return { ok: true };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: { responses: {
+			200: {
+				description: "Output cleared",
+				content: { "application/json": { schema: {
+					type: "object",
+					required: ["ok"],
+					properties: { ok: {
+						type: "boolean",
+						const: true
+					} }
+				} } }
+			},
+			400: errorResponseDocument("Invalid request"),
+			404: errorResponseDocument("Output not found"),
+			409: errorResponseDocument("Lifecycle conflict"),
+			503: errorResponseDocument("Transport or persistence unavailable")
+		} },
+		params: outputParamsSchema
+	});
+	if (options.viewer) app.get("/viewer/universes", () => ({ universes: options.viewer?.getSelectedUniverses() ?? [] }), { detail: { responses: componentResponse("ViewerState", "Selected viewer universes") } }).get("/viewer/telemetry", () => options.viewer?.getTelemetry(), { detail: { responses: componentResponse("ViewerTelemetry", "Viewer telemetry") } }).put("/viewer/universes", async ({ body, set }) => {
+		try {
+			const record = bodyObject(body);
+			if (!Array.isArray(record.universes)) throw new SacnValidationError("Body must contain a universes array.", "INVALID_UNIVERSE");
+			return { universes: await options.viewer?.setSelectedUniverses(record.universes) };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: viewerStateSchema,
+		detail: { responses: componentResponse("ViewerState", "Updated viewer universes") }
+	}).post("/viewer/universes/:universe", async ({ params, set }) => {
+		try {
+			return { universes: await options.viewer?.addUniverse(integerParam(params.universe, "Universe")) };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: { responses: componentResponse("ViewerState", "Updated viewer universes") },
+		params: viewerUniverseParamsSchema
+	}).delete("/viewer/universes/:universe", async ({ params, set }) => {
+		try {
+			return { universes: await options.viewer?.removeUniverse(integerParam(params.universe, "Universe")) };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: { responses: componentResponse("ViewerState", "Updated viewer universes") },
+		params: viewerUniverseParamsSchema
+	}).delete("/viewer/universes", async ({ set }) => {
+		try {
+			return { universes: await options.viewer?.setSelectedUniverses([]) };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, { detail: { responses: componentResponse("ViewerState", "Cleared viewer universes") } }).ws("/viewer/ws", {
+		open(ws) {
+			if (clients.size >= maxWebSocketClients) {
+				ws.close();
+				return;
+			}
+			const client = {
+				socket: ws,
+				pending: /* @__PURE__ */ new Map(),
+				scheduled: false
+			};
+			clients.add(client);
+			ws.send({
+				type: "viewer-state",
+				viewer: { universes: options.viewer?.getSelectedUniverses() ?? [] }
+			});
+		},
+		close(ws) {
+			for (const client of clients) if (client.socket === ws) {
+				clients.delete(client);
+				client.pending.clear();
+				break;
+			}
+		},
+		message() {}
+	});
+	const mark = (set, successor) => deprecated(set, `${prefix}${successor}`, sunset);
+	return app.get("/outputs", async ({ set }) => {
+		mark(set, "/universes");
+		try {
+			return await options.source.listUniverses();
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, { detail: {
+		deprecated: true,
+		responses: { 200: {
+			description: "Active outputs",
+			content: { "application/json": { schema: {
+				type: "array",
+				items: { $ref: "#/components/schemas/OutputSnapshot" }
+			} } }
+		} }
+	} }).get("/telemetry", ({ set }) => {
+		mark(set, "/engine/telemetry");
+		return options.source.getTelemetry();
+	}, { detail: {
+		deprecated: true,
+		responses: componentResponse("EngineTelemetry", "Engine telemetry")
+	} }).get("/outputs/:universe/:priority", async ({ params, set }) => {
+		mark(set, `/universes/${params.universe}/priorities/${params.priority}`);
+		try {
+			const output = await universeOf(options.source, params).get();
+			if (!output) {
+				set.status = 404;
+				return { error: "Output not found." };
+			}
+			return output;
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: {
+			deprecated: true,
+			responses: outputLookupResponseDocument
+		},
+		params: outputParamsSchema
+	}).put("/outputs/:universe/:priority", async ({ body, params, set }) => {
+		mark(set, `/universes/${params.universe}/priorities/${params.priority}`);
+		try {
+			const record = bodyObject(body);
+			const frame = frameFrom({
+				...record,
+				values: record.initialValues ?? record.values ?? Array.from({ length: 512 }, () => 0)
+			});
+			const universe = universeOf(options.source, params, {
+				...frame.cid === void 0 ? {} : { cid: frame.cid },
+				...frame.idleFps === void 0 ? {} : { idleFps: frame.idleFps },
+				...frame.sourceName === void 0 ? {} : { sourceName: frame.sourceName }
+			});
+			const existing = await universe.get();
+			const supplied = record.initialValues ?? record.values;
+			const values = Array.isArray(supplied) || supplied instanceof Uint8Array ? supplied : existing?.target ?? Array.from({ length: 512 }, () => 0);
+			return await universe.write(values, { ...frame.durationMs === void 0 ? {} : { durationMs: frame.durationMs } });
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: upsertBodySchema,
+		detail: {
+			deprecated: true,
+			responses: outputResponseDocument
+		},
+		params: outputParamsSchema
+	}).post("/outputs/:universe/:priority/channels", async ({ body, params, set }) => {
+		mark(set, `/universes/${params.universe}/priorities/${params.priority}/channels`);
+		try {
+			const parsed = channelsFrom(body);
+			const universe = universeOf(options.source, params, {
+				...parsed.cid === void 0 ? {} : { cid: parsed.cid },
+				...parsed.idleFps === void 0 ? {} : { idleFps: parsed.idleFps },
+				...parsed.sourceName === void 0 ? {} : { sourceName: parsed.sourceName }
+			});
+			return await applyChannels(universe, parsed);
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: channelsBodySchema,
+		detail: {
+			deprecated: true,
+			responses: outputResponseDocument
+		},
+		params: outputParamsSchema
+	}).post("/outputs/:universe/:priority/frame", async ({ body, params, set }) => {
+		mark(set, `/universes/${params.universe}/priorities/${params.priority}/frame`);
+		try {
+			const frame = frameFrom(body);
+			return await universeOf(options.source, params, {
+				...frame.cid === void 0 ? {} : { cid: frame.cid },
+				...frame.idleFps === void 0 ? {} : { idleFps: frame.idleFps },
+				...frame.sourceName === void 0 ? {} : { sourceName: frame.sourceName }
+			}).write(frame.values, { ...frame.durationMs === void 0 ? {} : { durationMs: frame.durationMs } });
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		body: frameBodySchema,
+		detail: {
+			deprecated: true,
+			responses: outputResponseDocument
+		},
+		params: outputParamsSchema
+	}).delete("/outputs/:universe/:priority", async ({ params, set }) => {
+		mark(set, `/universes/${params.universe}/priorities/${params.priority}`);
+		try {
+			if (!await universeOf(options.source, params).clear()) {
+				set.status = 404;
+				return { error: "Output not found." };
+			}
+			return { ok: true };
+		} catch (error) {
+			return fail(set, error);
+		}
+	}, {
+		detail: {
+			deprecated: true,
+			responses: clearResponseDocument
+		},
+		params: outputParamsSchema
+	});
+};
+/** Connects viewer packets to a host-owned WebSocket or SSE implementation. */
+const subscribeViewerPackets = (viewer, listener) => viewer.subscribe(listener);
+//#endregion
+export { createSacnHttpAdapter, subscribeViewerPackets };
+
+//# sourceMappingURL=http.js.map