watch-tail 0.4.0 → 0.6.0

package/build/server/chunks/entries/endpoints/api/stream/{_server.ts.js-CIYo4C-0.js → _server.ts.js-BWRHawY8.js}

@@ -1,209 +1,169 @@
-import { a as apiError, p as parseRegionParam, b as readEnv, r as resolveAwsConfig, c as createLogsClient, d as resolveEffectiveRegion, e as describeAwsError, R as REGION_PARAM_HINT } from '../../../../chunks/env2.js-DXveJt1Y.js';
-import { H as HISTORIC_PRESETS, p as presetDurationMs, i as isHistoricPreset } from '../../../../chunks/time-range.js-BLMT8aU3.js';
+import { g as getArchive } from '../../../../chunks/archive.js-C2D-5edp.js';
+import { r as readEnv } from '../../../../chunks/env2.js-CcIskxOZ.js';
+import { a as apiError, p as parseRegionParam, r as resolveAwsConfig, c as createLogsClient, d as describeAwsError, b as resolveEffectiveRegion, R as REGION_PARAM_HINT } from '../../../../chunks/aws.js-DkPqAybc.js';
+import { p as parseSourceParam, S as SOURCE_PARAM_HINT } from '../../../../chunks/source.js-DZEVvuho.js';
+import { p as parseGroupParams, a as parseLevelParam, r as resolveWindow, c as clampPollMs, w as withDetections, L as LEVEL_PARAM_HINT } from '../../../../chunks/level-filter.js-B3o2hyWD.js';
 import '../../../../chunks/utils.js-BIlHjgGW.js';
 import { FilterLogEventsCommand } from '@aws-sdk/client-cloudwatch-logs';
-import '../../../../chunks/shared-server.js-Dn5XheXH.js';
-import '@aws-sdk/client-sts';
+import '../../../../chunks/log-buffer.js-BI_gQOls.js';
 import 'node:fs';
+import 'node:os';
 import 'node:path';
+import 'node:timers/promises';
+import 'node:crypto';
+import '../../../../chunks/shared-server.js-Dn5XheXH.js';
+import '@aws-sdk/client-sts';
+import '../../../../chunks/time-range.js-BLMT8aU3.js';
 import '../../../../chunks/shared.js-CgjUIvRK.js';
 import '../../../../chunks/uneval.js-DaakSYFQ.js';
 
-//#region src/lib/server/filter.ts
-/** Default lookback window when neither `startTime` nor `lookback` is usable. */
-var DEFAULT_LOOKBACK_MS = 3e5;
-/** CloudWatch Logs rejects `startTime` older than 14 days. */
-var MAX_LOOKBACK_MS = 12096e5;
-var DEFAULT_POLL_MS$1 = 1e3;
-var MIN_POLL_MS = 250;
-var MAX_POLL_MS = 15e3;
-var DURATION_UNITS = {
-	ms: 1,
-	s: 1e3,
-	m: 6e4,
-	h: 36e5,
-	d: 864e5,
-	w: 6048e5
-};
-var DURATION_PATTERN = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/i;
-var EPOCH_PATTERN = /^\d+$/;
-/**
-* Parses a single-unit duration such as `500ms`, `30s`, `15m`, `2h`, `3d` or
-* `1w`. Returns `null` for anything invalid, negative or zero.
-*/
-function parseDurationMs(value) {
-	if (typeof value !== "string") return null;
-	const match = DURATION_PATTERN.exec(value.trim());
-	if (match === null) return null;
-	const amount = Number(match[1]);
-	const unit = DURATION_UNITS[match[2].toLowerCase()];
-	if (unit === void 0 || !Number.isFinite(amount)) return null;
-	const ms = amount * unit;
-	if (!Number.isFinite(ms) || ms <= 0) return null;
-	return Math.round(ms);
-}
-/**
-* Parses a start point into epoch milliseconds.
-*
-* Accepts epoch milliseconds (`1700000000000`), a duration relative to `now`
-* (`15m`) and ISO 8601 timestamps. Returns `null` when the value is missing or
-* cannot be understood.
-*/
-function parseStartTime(value, now) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	if (trimmed.length === 0) return null;
-	if (EPOCH_PATTERN.test(trimmed)) return Number(trimmed);
-	const duration = parseDurationMs(trimmed);
-	if (duration !== null) return now - duration;
-	const parsed = Date.parse(trimmed);
-	return Number.isNaN(parsed) ? null : parsed;
-}
-/** Resolves the effective start time, clamped to the last 14 days and to `now`. */
-function resolveStartTime(input) {
-	const { now } = input;
-	let start = parseStartTime(input.startTime, now);
-	if (start === null) start = now - (parseDurationMs(input.lookback ?? "") ?? DEFAULT_LOOKBACK_MS);
-	const oldestAllowed = now - MAX_LOOKBACK_MS;
-	if (start > now) start = now;
-	if (start < oldestAllowed) start = oldestAllowed;
-	return Math.round(start);
-}
-/** Parses a poll interval in milliseconds, defaulting to 1000 and clamped to 250..15000. */
-function clampPollMs(value) {
-	if (typeof value !== "string") return DEFAULT_POLL_MS$1;
-	const trimmed = value.trim();
-	if (trimmed.length === 0) return DEFAULT_POLL_MS$1;
-	const parsed = Number(trimmed);
-	if (!Number.isFinite(parsed)) return DEFAULT_POLL_MS$1;
-	return Math.min(Math.max(Math.round(parsed), MIN_POLL_MS), MAX_POLL_MS);
-}
-/** Default historic window when neither `range` nor `from`/`to` is given. */
-var DEFAULT_HISTORIC_PRESET = "15m";
-/** Parses the `mode` parameter; `null` for an unrecognised value. */
-function parseMode(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim().toLowerCase();
-	if (trimmed === "live" || trimmed === "historic") return trimmed;
-	return null;
+//#region src/lib/server/archive-tail.ts
+/** Page size used when the caller does not ask for one. */
+var DEFAULT_ARCHIVE_PAGE_SIZE = 1e3;
+/** Upper bound on one page, so a huge window cannot exhaust memory. */
+var MAX_ARCHIVE_PAGE_SIZE = 5e3;
+/** Events one archive request may return before it stops (matches the tailer). */
+var DEFAULT_ARCHIVE_MAX_EVENTS = 1e4;
+/** Message shown when DuckDB is missing or the file cannot be opened. */
+function archiveUnavailableMessage(archive) {
+	const reason = archive.error;
+	const base = "The local archive is not available on this machine";
+	return reason === null || reason.length === 0 ? base : `${base}: ${reason}`;
 }
 /**
-* Parses an absolute instant: epoch milliseconds or an ISO 8601 timestamp.
+* Yields archived events for one window, oldest first.
 *
-* Relative durations are deliberately rejected here so an end bound can never
-* move with the clock.
+* An unavailable archive produces a single `error` batch instead of throwing, so
+* the browser shows a normal stream error. An aborted signal ends the generator
+* without yielding an `end` batch, which is what the route treats as a
+* client disconnect.
 */
-function parseInstant(value) {
-	if (typeof value !== "string") return null;
-	const trimmed = value.trim();
-	if (trimmed.length === 0) return null;
-	if (EPOCH_PATTERN.test(trimmed)) return Number(trimmed);
-	const parsed = Date.parse(trimmed);
-	return Number.isNaN(parsed) ? null : parsed;
+async function* tailArchivedEvents(options) {
+	const { archive, region, logGroups, startTime, endTime, search = null, streamPrefix = null, levels = null, signal } = options;
+	if (!archive.available) {
+		yield {
+			type: "error",
+			message: archiveUnavailableMessage(archive),
+			code: "archive-unavailable"
+		};
+		return;
+	}
+	const requestedPageSize = options.pageSize ?? 1e3;
+	const pageSize = Math.min(Math.max(Number.isFinite(requestedPageSize) ? Math.round(requestedPageSize) : DEFAULT_ARCHIVE_PAGE_SIZE, 1), MAX_ARCHIVE_PAGE_SIZE);
+	const requestedMax = options.maxEvents ?? 1e4;
+	const maxEvents = Number.isFinite(requestedMax) && requestedMax > 0 ? Math.floor(requestedMax) : DEFAULT_ARCHIVE_MAX_EVENTS;
+	let cursor = null;
+	let emitted = 0;
+	for (;;) {
+		if (signal?.aborted === true) return;
+		const page = await archive.page({
+			region,
+			logGroups,
+			startTime,
+			endTime,
+			search,
+			streamPrefix,
+			levels,
+			after: cursor,
+			limit: pageSize
+		});
+		if (page.events.length === 0) {
+			yield {
+				type: "end",
+				reason: "window-complete"
+			};
+			return;
+		}
+		emitted += page.events.length;
+		yield {
+			type: "events",
+			events: page.events
+		};
+		cursor = page.last;
+		if (cursor === null || page.events.length < pageSize) {
+			yield {
+				type: "end",
+				reason: "window-complete"
+			};
+			return;
+		}
+		if (emitted >= maxEvents) {
+			yield {
+				type: "end",
+				reason: "event-limit"
+			};
+			return;
+		}
+	}
 }
-/**
-* Clamps a window to what CloudWatch Logs can return: 14 days back, ending now.
-*
-* Returns `null` when the requested window ends before the retention floor, so
-* a request for month-old data fails loudly instead of returning a stub window.
-*/
-function clampWindow(start, end, now) {
-	const oldest = now - MAX_LOOKBACK_MS;
-	if (end <= oldest) return null;
-	const clampedStart = Math.min(Math.max(start, oldest), now);
-	const clampedEnd = Math.min(Math.max(end, clampedStart + 1), now);
-	return {
-		start: Math.round(clampedStart),
-		end: Math.round(clampedEnd),
-		clamped: clampedStart !== Math.round(start) || clampedEnd !== Math.round(end)
-	};
+//#endregion
+//#region src/lib/server/multi-tail.ts
+/** Events-payload batch reasons, worst first. */
+var END_PRECEDENCE = [
+	"repeated-errors",
+	"event-limit",
+	"window-complete"
+];
+/** Picks the most serious end reason from the sources. */
+function mergeEndReason(reasons) {
+	for (const candidate of END_PRECEDENCE) if (reasons.includes(candidate)) return candidate;
+	return "window-complete";
 }
 /**
-* Resolves the request window into a start time plus, for historic mode, an end
-* time.
+* Yields every batch of every source, then one `end`.
 *
-* Historic windows come from a preset (`range=24h`), from explicit bounds
-* (`from`/`to`, epoch ms or ISO 8601) or, when neither is given, from the
-* smallest preset. Windows are clamped to the last 14 days and to `now` so the
-* request can never ask CloudWatch for data it will not return.
+* A failing source yields its own `error` batch; it never cancels the others, so
+* one unreadable group does not silence the rest of the view.
 */
-function resolveWindow(input) {
-	const { now } = input;
-	const requestedMode = input.mode === null || input.mode === void 0 ? "live" : input.mode.trim();
-	const mode = requestedMode === "" ? "live" : parseMode(requestedMode);
-	if (mode === null) return {
-		ok: false,
-		code: "invalid-mode",
-		message: "Invalid mode: expected \"live\" or \"historic\""
-	};
-	if (mode === "live") return {
-		ok: true,
-		mode,
-		startTime: resolveStartTime({
-			startTime: input.startTime,
-			lookback: input.lookback,
-			now
-		}),
-		endTime: null,
-		preset: null,
-		clamped: false
-	};
-	const from = input.from?.trim() ?? "";
-	const to = input.to?.trim() ?? "";
-	if (from.length > 0 || to.length > 0) {
-		if (from.length === 0 || to.length === 0) return {
-			ok: false,
-			code: "invalid-window",
-			message: "A custom window needs both \"from\" and \"to\""
-		};
-		const parsedFrom = parseStartTime(from, now);
-		const parsedTo = parseInstant(to);
-		if (parsedFrom === null) return {
-			ok: false,
-			code: "invalid-time",
-			message: `Invalid "from": expected epoch milliseconds, a duration such as 3h, or an ISO 8601 timestamp`
-		};
-		if (parsedTo === null) return {
-			ok: false,
-			code: "invalid-time",
-			message: "Invalid \"to\": expected epoch milliseconds or an ISO 8601 timestamp"
-		};
-		if (parsedTo <= parsedFrom) return {
-			ok: false,
-			code: "invalid-window",
-			message: "The end of the window must be after its start"
-		};
-		const clamped = clampWindow(parsedFrom, parsedTo, now);
-		if (clamped === null || clamped.end <= clamped.start) return {
-			ok: false,
-			code: "invalid-window",
-			message: "The requested window is outside the 14 days CloudWatch Logs keeps"
-		};
-		return {
-			ok: true,
-			mode,
-			startTime: clamped.start,
-			endTime: clamped.end,
-			preset: null,
-			clamped: clamped.clamped
-		};
+async function* mergeTails(sources) {
+	if (sources.length === 0) return;
+	if (sources.length === 1) {
+		yield* sources[0];
+		return;
 	}
-	const requestedRange = input.range?.trim() ?? "";
-	const preset = requestedRange === "" ? DEFAULT_HISTORIC_PRESET : isHistoricPreset(requestedRange) ? requestedRange : null;
-	if (preset === null) return {
-		ok: false,
-		code: "invalid-range",
-		message: `Invalid range: expected one of ${HISTORIC_PRESETS.join(", ")} or an explicit from/to window`
-	};
-	const end = Math.round(now);
-	return {
-		ok: true,
-		mode,
-		startTime: Math.round(now - presetDurationMs(preset)),
-		endTime: end,
-		preset,
-		clamped: false
+	const queue = [];
+	let waiting = null;
+	/** Sources whose end marker has been consumed, so their batches are all out. */
+	let completed = 0;
+	const endReasons = [];
+	const push = (item) => {
+		queue.push(item);
+		const wake = waiting;
+		waiting = null;
+		wake?.();
 	};
+	for (const source of sources) (async () => {
+		let endReason = null;
+		try {
+			for await (const batch of source) if (batch.type === "end") endReason = batch.reason;
+			else push({ batch });
+		} catch {} finally {
+			if (endReason !== null) endReasons.push(endReason);
+			push({ done: true });
+		}
+	})();
+	for (;;) {
+		if (queue.length === 0) {
+			if (completed >= sources.length) {
+				yield {
+					type: "end",
+					reason: mergeEndReason(endReasons)
+				};
+				return;
+			}
+			await new Promise((resolve) => {
+				waiting = resolve;
+				if (queue.length > 0 || completed >= sources.length) {
+					waiting = null;
+					resolve();
+				}
+			});
+			continue;
+		}
+		const item = queue.shift();
+		if ("batch" in item) yield item.batch;
+		else completed += 1;
+	}
 }
 //#endregion
 //#region src/lib/server/sse.ts
@@ -435,6 +395,16 @@ async function* tailLogEvents(options) {
 var PING_INTERVAL_MS = 15e3;
 /** Stop the stream after this many consecutive failed polls. */
 var MAX_CONSECUTIVE_ERRORS = 8;
+/** Bounds for the archive `pageSize` parameter. */
+var ARCHIVE_PAGE_LIMITS = {
+	min: 1,
+	max: 5e3
+};
+/** Bounds for the archive `max` parameter (events per request). */
+var ARCHIVE_MAX_LIMITS = {
+	min: 1,
+	max: 1e5
+};
 var SSE_HEADERS = {
 	"content-type": "text/event-stream; charset=utf-8",
 	"cache-control": "no-cache, no-transform",
@@ -442,44 +412,180 @@ var SSE_HEADERS = {
 	"x-accel-buffering": "no"
 };
 /**
+* Tags every event of one tail with its log group.
+*
+* A merged multi-group stream has to say which group each line came from, both
+* for the archive and for the group column in the viewer.
+*/
+async function* taggedEvents(source, group) {
+	for await (const batch of source) {
+		if (batch.type !== "events") {
+			yield batch;
+			continue;
+		}
+		const events = [];
+		for (const event of batch.events) events.push({
+			...event,
+			group
+		});
+		yield {
+			type: "events",
+			events
+		};
+	}
+}
+/**
+* Writes one batch to the archive, under the right group.
+*
+* A merged multi-group stream tags every event with its own group, so a batch
+* that mixes groups is split; a single-group stream falls back to the group the
+* request named.
+*/
+async function recordBatch(archive, region, groupNames, events) {
+	const fallback = groupNames[0] ?? "";
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const group = event.group ?? fallback;
+		const bucket = byGroup.get(group);
+		if (bucket === void 0) byGroup.set(group, [event]);
+		else bucket.push(event);
+	}
+	for (const [group, groupEvents] of byGroup) await archive.record(region, group, groupEvents);
+}
+/**
+* Parses a positive integer parameter within `limits`.
+*
+* Returns `null` for a missing value (meaning "use the default") and for an
+* unusable one, so a typo falls back to the default instead of failing the
+* stream; an out-of-range value is clamped rather than rejected.
+*/
+function parseBoundedInt(value, limits) {
+	if (value === null) return null;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return null;
+	const parsed = Number(trimmed);
+	if (!Number.isFinite(parsed)) return null;
+	return Math.min(Math.max(Math.round(parsed), limits.min), limits.max);
+}
+/**
+* Builds the feed for a request.
+*
+* The archive path never creates a CloudWatch client, so browsing history works
+* with no credentials and no network; it does need a region, because archived
+* rows are stored per region. Failures come back as an `apiError` response the
+* route returns unchanged.
+*/
+async function resolveFeed(request) {
+	const { source, config, env, groupNames, startTime, endTime, signal } = request;
+	if (source === "archive") {
+		const region = config.region ?? "";
+		if (region === "") return apiError(400, "Query parameter \"region\" is required when source=archive", "missing-region-param");
+		return {
+			region,
+			groupNames,
+			generator: tailArchivedEvents({
+				archive: await getArchive(env),
+				region,
+				logGroups: groupNames,
+				startTime,
+				endTime: endTime ?? Date.now(),
+				search: request.search,
+				levels: request.levels,
+				...request.pageSize === null ? {} : { pageSize: request.pageSize },
+				...request.maxEvents === null ? {} : { maxEvents: request.maxEvents },
+				signal
+			}),
+			release: () => void 0
+		};
+	}
+	let client;
+	try {
+		client = createLogsClient(config);
+	} catch (error) {
+		const described = describeAwsError(error);
+		return apiError(502, described.message, described.code);
+	}
+	let region;
+	try {
+		region = await resolveEffectiveRegion(client, config);
+	} catch (error) {
+		client.destroy();
+		const described = describeAwsError(error);
+		return apiError(502, described.message, described.code);
+	}
+	const tails = groupNames.map((group) => taggedEvents(tailLogEvents({
+		client,
+		logGroupName: group,
+		startTime,
+		endTime,
+		pollIntervalMs: request.pollIntervalMs,
+		filterPattern: request.filterPattern,
+		signal,
+		maxConsecutiveErrors: MAX_CONSECUTIVE_ERRORS
+	}), group));
+	return {
+		region,
+		groupNames,
+		generator: mergeTails(tails),
+		release: () => client.destroy()
+	};
+}
+/**
 * `GET /api/stream` - server-sent events for one log group.
 *
 * Emits `ready` first, then `log` per batch, `ping` after 15 s of silence and
-* a final `end`. The region is optional: without it the tailer uses a client
-* that resolves the region from the ambient AWS configuration. The tailer is
-* cancelled through `request.signal`, and every timer and listener is removed
-* so the dev server can exit.
+* a final `end`. `source=cloudwatch` (the default) polls CloudWatch Logs with
+* the ambient credentials; `source=archive` replays the local DuckDB archive and
+* needs neither credentials nor a region parameter resolution.
+*
+* The stream is cancelled through `request.signal`, and every timer and listener
+* is removed so the dev server can exit.
 */
 var GET = async ({ url, request }) => {
-	const logGroupName = url.searchParams.get("group")?.trim() ?? "";
-	if (logGroupName.length === 0) return apiError(400, "Query parameter \"group\" is required", "missing-group");
+	const groupSelection = parseGroupParams(url.searchParams.get("group"), url.searchParams.get("groups"));
+	if (!groupSelection.ok) return apiError(400, groupSelection.message, groupSelection.code);
+	const groupNames = groupSelection.names;
 	const parsedRegion = parseRegionParam(url.searchParams.get("region"));
 	if (!parsedRegion.ok) return apiError(400, REGION_PARAM_HINT, "invalid-region");
+	const source = parseSourceParam(url.searchParams.get("source"));
+	if (source === null) return apiError(400, SOURCE_PARAM_HINT, "invalid-source");
 	const env = readEnv();
 	const config = resolveAwsConfig(env, parsedRegion.region);
 	const filterPattern = url.searchParams.get("filterPattern")?.trim();
+	const search = url.searchParams.get("search")?.trim() ?? "";
+	const levels = parseLevelParam(url.searchParams.get("level"));
+	if (levels === void 0) return apiError(400, LEVEL_PARAM_HINT, "invalid-level");
+	if (levels !== null && source !== "archive") return apiError(400, "The \"level\" filter applies to source=archive; use filterPattern to filter CloudWatch", "invalid-level");
 	const streamWindow = resolveWindow({
-		mode: url.searchParams.get("mode"),
+		mode: url.searchParams.get("mode") ?? (source === "archive" ? "historic" : null),
 		range: url.searchParams.get("range"),
 		from: url.searchParams.get("from"),
 		to: url.searchParams.get("to"),
 		startTime: url.searchParams.get("startTime"),
 		lookback: url.searchParams.get("lookback"),
 		now: Date.now()
-	});
+	}, source === "archive" ? { maxLookbackMs: null } : {});
 	if (!streamWindow.ok) return apiError(400, streamWindow.message, streamWindow.code);
-	const pollIntervalMs = clampPollMs(url.searchParams.get("poll"));
-	let client;
-	let region;
-	try {
-		client = createLogsClient(config);
-		region = await resolveEffectiveRegion(client, config);
-	} catch (error) {
-		const described = describeAwsError(error);
-		return apiError(502, described.message, described.code);
-	}
-	const encoder = new TextEncoder();
+	if (source === "archive" && streamWindow.mode === "live") return apiError(400, "The local archive only serves historic windows: use mode=historic, or source=cloudwatch to tail live", "invalid-mode");
 	const bodyAbort = new AbortController();
+	const feed = await resolveFeed({
+		source,
+		config,
+		env,
+		groupNames,
+		startTime: streamWindow.startTime,
+		endTime: streamWindow.endTime,
+		filterPattern,
+		search: search.length === 0 ? null : search,
+		levels,
+		pageSize: parseBoundedInt(url.searchParams.get("pageSize"), ARCHIVE_PAGE_LIMITS),
+		maxEvents: parseBoundedInt(url.searchParams.get("max"), ARCHIVE_MAX_LIMITS),
+		pollIntervalMs: clampPollMs(url.searchParams.get("poll")),
+		signal: bodyAbort.signal
+	});
+	if (feed instanceof Response) return feed;
+	const archive = source === "cloudwatch" ? await getArchive(env) : null;
+	const encoder = new TextEncoder();
 	let streamController;
 	let closed = false;
 	let pingTimer;
@@ -533,27 +639,20 @@ var GET = async ({ url, request }) => {
 		cleanedUp = true;
 		clearPing();
 		request.signal.removeEventListener("abort", onAbort);
-		client.destroy();
+		feed.release();
 	};
 	const pump = async () => {
 		let consecutiveErrors = 0;
 		let reason = "completed";
 		try {
-			for await (const batch of tailLogEvents({
-				client,
-				logGroupName,
-				startTime: streamWindow.startTime,
-				endTime: streamWindow.endTime,
-				pollIntervalMs,
-				filterPattern,
-				signal: bodyAbort.signal,
-				maxConsecutiveErrors: MAX_CONSECUTIVE_ERRORS
-			})) {
+			for await (const batch of feed.generator) {
 				if (closed || bodyAbort.signal.aborted) break;
 				if (batch.type === "events") {
-					const payload = { events: batch.events };
+					const events = withDetections(batch.events);
+					const payload = { events };
 					consecutiveErrors = 0;
 					enqueue(sseFrame("log", payload));
+					if (archive !== null) await recordBatch(archive, feed.region, feed.groupNames, events);
 				} else if (batch.type === "end") {
 					reason = batch.reason;
 					break;
@@ -584,9 +683,11 @@ var GET = async ({ url, request }) => {
 		start(controller) {
 			streamController = controller;
 			const payload = {
-				region,
-				logGroupName,
-				endpoint: config.endpoint,
+				region: feed.region,
+				logGroupName: feed.groupNames[0] ?? "",
+				groups: [...feed.groupNames],
+				endpoint: source === "archive" ? null : config.endpoint,
+				source,
 				startTime: streamWindow.startTime,
 				endTime: streamWindow.endTime,
 				mode: streamWindow.mode,
@@ -608,4 +709,4 @@ var GET = async ({ url, request }) => {
 };
 
 export { GET };
-//# sourceMappingURL=_server.ts.js-CIYo4C-0.js.map
+//# sourceMappingURL=_server.ts.js-BWRHawY8.js.map