@devdogsuga/backstage 0.1.8 → 0.1.10

package/dist/commands-C8pXvbv1.js

@@ -0,0 +1,699 @@
+import { n as isDryRun } from "./dry-run-CFCZUpjb.js";
+import { o as unwrap, r as errorMessage, t as UsageError } from "./ui-Bb69ZfVv.js";
+import { i as exportParams, n as EXPORT_KINDS, r as auditFilters, t as EXPORTS } from "./queries-D3mTchag.js";
+import { t as DONE } from "./dispatch-D048O65I.js";
+import { c as ProductionError, d as requireProductionKey, i as plural, l as connect, o as reportFailure, r as expandHome, s as say, t as canPrompt, u as dbError } from "./cli-DjIwbjnx.js";
+import { i as parseBound, n as findMeetingsWith, r as pickMeeting, t as describeMeeting } from "./meetings-Du5asTAj.js";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { autocomplete, confirm, multiselect, text } from "@clack/prompts";
+import { open, rm } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { parseArgs, promisify } from "node:util";
+/**
+* Quotes a field only when it has to be: a comma, a quote, a carriage return
+* or a line feed. Quoting only what needs it keeps the file readable in a
+* terminal.
+*
+* A leading `=`, `+`, `-`, `@`, tab or carriage return gets a tab prefix:
+* spreadsheets start a formula on the first four, and a member can name their
+* team `=cmd|'/c calc'!A1`. The tab is invisible in a cell and neutralises it.
+*/
+function csvField(value) {
+	if (value === null || value === void 0) return "";
+	let text;
+	if (typeof value === "string") text = value;
+	else if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") text = String(value);
+	else if (value instanceof Date) text = csvTimestamp(value);
+	else text = JSON.stringify(value) ?? "";
+	const guarded = /^[=+\-@\t\r]/.test(text) ? `\t${text}` : text;
+	if (!/[",\r\n]/.test(guarded)) return guarded;
+	return `"${guarded.replace(/"/g, "\"\"")}"`;
+}
+function csvRow(values) {
+	return values.map(csvField).join(",") + "\r\n";
+}
+/**
+* ISO 8601 with an explicit offset, never a bare local time: a timestamp
+* without one is read in whatever zone the importer runs in.
+*/
+function csvTimestamp(value) {
+	if (value === null) return "";
+	const date = value instanceof Date ? value : new Date(value);
+	return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+}
+//#endregion
+//#region src/production/save-path.ts
+/**
+* "Where should this go?": a save-as prompt with path completion.
+*
+* clack's own `path` prompt only submits a path that already exists (it is a
+* picker), so a new file name cannot be typed into it. This is the same
+* `autocomplete` underneath, with the typed path itself always first: Enter
+* saves exactly what was typed, the arrow keys pick a suggestion, and Tab
+* completes the highlighted one into the input to keep typing from, the way
+* a shell does. A directory, typed or picked, means the suggested file name
+* inside it.
+*/
+function isDirectory$1(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* What to offer for `input`: the input itself, then the entries of the
+* directory it is being typed into whose names start with what follows the
+* last `/`, directories first and marked with a trailing `/`. Dotfiles only
+* when the name being typed starts with a dot. Values keep the input's own
+* spelling (`~/`, `./`) so completing one never rewrites what was typed.
+*/
+function pathSuggestions(input, fileName) {
+	if (!input) return [];
+	const full = expandHome(input);
+	const own = {
+		value: input,
+		label: input,
+		hint: isDirectory$1(full) ? `saves ${join(input, fileName)}` : existsSync(full) ? "replaces this file" : isDirectory$1(dirname(full)) ? "new file" : "no such folder"
+	};
+	const cut = input.lastIndexOf("/") + 1;
+	const lead = input.slice(0, cut);
+	const prefix = input.slice(cut);
+	let names;
+	try {
+		names = readdirSync(expandHome(lead || "."));
+	} catch {
+		return [own];
+	}
+	const shown = (name) => name.startsWith(prefix) && (prefix.startsWith(".") || !name.startsWith("."));
+	return [own, ...names.filter(shown).map((name) => {
+		const value = lead + name;
+		return {
+			name,
+			value,
+			directory: isDirectory$1(expandHome(value))
+		};
+	}).sort((a, b) => Number(b.directory) - Number(a.directory) || a.name.localeCompare(b.name)).map(({ value, directory }) => ({
+		value: directory ? `${value}/` : value,
+		label: directory ? `${value}/` : value
+	})).filter((s) => s.value !== input)];
+}
+/** The file a submitted path names: a directory means `fileName` inside it. */
+function resolveSavePath(input, fileName) {
+	const full = expandHome(input.trim());
+	return isDirectory$1(full) ? join(full, fileName) : full;
+}
+/**
+* Asks where to save a file, suggesting `suggested`. An existing file is only
+* replaced after a second, default-no question; answering no asks again.
+* Returns the full path (`~` expanded, a directory resolved to the file in it).
+*/
+async function askSavePath(options) {
+	const fileName = basename(options.suggested);
+	for (;;) {
+		let wired = false;
+		const path = resolveSavePath(unwrap(await autocomplete({
+			message: options.message,
+			initialUserInput: options.suggested,
+			maxItems: 6,
+			filter: () => true,
+			options() {
+				if (!wired) {
+					wired = true;
+					const prompt = this;
+					prompt.on("key", (_char, key) => {
+						const focused = prompt.focusedValue;
+						if (key.name !== "tab" || typeof focused !== "string") return;
+						prompt._clearUserInput();
+						prompt._setUserInput(focused, true);
+					});
+				}
+				return pathSuggestions(this.userInput, fileName);
+			},
+			validate: (value) => {
+				if (typeof value !== "string" || !value.trim()) return "A path, please.";
+				const folder = dirname(resolveSavePath(value, fileName));
+				return isDirectory$1(folder) ? void 0 : `${folder} does not exist.`;
+			}
+		})), fileName);
+		if (!existsSync(path)) return path;
+		if (unwrap(await confirm({
+			message: `${path} already exists. Replace it?`,
+			initialValue: false
+		}))) return path;
+	}
+}
+//#endregion
+//#region src/export/formats.ts
+/** What each export can be written as; the first is its default. */
+const FORMATS_BY_KIND = {
+	stars: ["platform"],
+	attendance: [
+		"platform",
+		"bevy",
+		"involvement"
+	],
+	reflections: ["platform"],
+	responses: ["platform", "wide"]
+};
+function text$1(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+/** The UGA address on file: the profile's MyID email, else a uga.edu sign-in. */
+function ugaEmail(row) {
+	const uga = text$1(row.uga_email).toLowerCase();
+	if (uga) return uga;
+	const signIn = text$1(row.email).toLowerCase();
+	return signIn.endsWith("@uga.edu") ? signIn : null;
+}
+/**
+* First and last name: the roster's (or legal) name when the profile has
+* one, else the preferred name split at its first space.
+*/
+function splitName(row) {
+	const first = text$1(row.first_name);
+	const last = text$1(row.last_name);
+	if (first || last) return [first, last];
+	const preferred = text$1(row.preferred_name);
+	const space = preferred.indexOf(" ");
+	return space === -1 ? [preferred, ""] : [preferred.slice(0, space), preferred.slice(space + 1).trim()];
+}
+/** One line per new key; rows without a key are counted as skipped. */
+function oncePer(key, line) {
+	const seen = /* @__PURE__ */ new Set();
+	const skipped = /* @__PURE__ */ new Set();
+	return {
+		page: (rows) => {
+			let out = "";
+			let count = 0;
+			for (const row of rows) {
+				const k = key(row);
+				if (k === null) {
+					skipped.add(text$1(row.user_id));
+					continue;
+				}
+				if (seen.has(k)) continue;
+				seen.add(k);
+				out += line(row, k);
+				count++;
+			}
+			return {
+				text: out,
+				count
+			};
+		},
+		skipped: () => skipped.size
+	};
+}
+const BEVY_COLUMNS = [
+	"first_name",
+	"last_name",
+	"email",
+	"checked_in",
+	"job_title",
+	"company",
+	"ticket_title",
+	"ticket_venue"
+];
+/** The platform's CSV for an export: its columns, a row per row. */
+function platformFormat(columns) {
+	return {
+		name: "platform",
+		label: "Platform CSV",
+		hint: "every column, one row per record",
+		suffix: "",
+		extension: "csv",
+		bom: true,
+		perEvent: false,
+		unit: ["row", "rows"],
+		needs: "",
+		head: csvRow(columns),
+		writer: () => ({
+			page: (rows) => ({
+				text: rows.map((row) => csvRow(columns.map((c) => row[c]))).join(""),
+				count: rows.length
+			}),
+			skipped: () => 0
+		})
+	};
+}
+function bevyFormat(survey = {
+	columns: [],
+	byUser: /* @__PURE__ */ new Map()
+}) {
+	return {
+		name: "bevy",
+		label: "Bevy attendee import",
+		hint: "gdg.community.dev; one row per person, checked in, survey answers",
+		suffix: "bevy",
+		extension: "csv",
+		bom: false,
+		perEvent: true,
+		unit: ["person", "people"],
+		needs: "an email",
+		head: csvRow([...BEVY_COLUMNS, ...survey.columns]),
+		writer: () => oncePer((row) => (ugaEmail(row) ?? text$1(row.email).toLowerCase()) || null, (row, email) => {
+			const [first, last] = splitName(row);
+			const answers = survey.byUser.get(text$1(row.user_id));
+			return csvRow([
+				first,
+				last,
+				email,
+				"TRUE",
+				"",
+				"",
+				"",
+				"",
+				...survey.columns.map((c) => answers?.get(c) ?? "")
+			]);
+		})
+	};
+}
+bevyFormat();
+/**
+* Survey responses as one row per person and one column per question (its
+* id), in the order questions first appear. Every row has to be in before the
+* header is known, so it writes everything at the end; one meeting's answers
+* are what it is for, which keeps that small.
+*/
+const WIDE = {
+	name: "wide",
+	label: "Wide table",
+	hint: "one row per person, one column per question",
+	suffix: "wide",
+	extension: "csv",
+	bom: true,
+	perEvent: true,
+	unit: ["person", "people"],
+	needs: "",
+	head: "",
+	writer: () => {
+		const questions = [];
+		const people = /* @__PURE__ */ new Map();
+		return {
+			page: (rows) => {
+				for (const row of rows) {
+					const question = text$1(row.question_id);
+					if (!questions.includes(question)) questions.push(question);
+					const id = text$1(row.user_id);
+					const person = people.get(id) ?? {
+						row,
+						answers: /* @__PURE__ */ new Map()
+					};
+					person.answers.set(question, row.answer);
+					people.set(id, person);
+				}
+				return {
+					text: "",
+					count: 0
+				};
+			},
+			skipped: () => 0,
+			end: () => {
+				const lead = [
+					"user_id",
+					"preferred_name",
+					"email"
+				];
+				let out = csvRow([...lead, ...questions]);
+				for (const { row, answers } of people.values()) out += csvRow([...lead.map((c) => row[c]), ...questions.map((q) => answers.get(q) ?? "")]);
+				return {
+					text: out,
+					count: people.size
+				};
+			}
+		};
+	}
+};
+const INVOLVEMENT = {
+	name: "involvement",
+	label: "Involvement Network list",
+	hint: "one MyID email per line",
+	suffix: "involvement",
+	extension: "txt",
+	bom: false,
+	perEvent: true,
+	unit: ["email", "emails"],
+	needs: "a UGA email",
+	head: "",
+	writer: () => oncePer(ugaEmail, (_row, email) => `${email}\r
+`)
+};
+function formatFor(name, columns, survey) {
+	if (name === "bevy") return bevyFormat(survey);
+	if (name === "involvement") return INVOLVEMENT;
+	if (name === "wide") return WIDE;
+	return platformFormat(columns);
+}
+/**
+* `--format` values for an export, comma-separated or repeated, checked
+* against what that export offers and deduplicated.
+*/
+function parseFormats(raw, kind) {
+	const offered = FORMATS_BY_KIND[kind];
+	const names = raw.flatMap((r) => r.split(",")).map((r) => r.trim().toLowerCase()).filter(Boolean);
+	for (const name of names) if (!offered.includes(name)) throw new Error(offered.length === 1 ? `The ${kind} export has one format; leave --format off.` : `Unknown format "${name}" for ${kind}. Try ${offered.join(", ")}.`);
+	return [...new Set(names)];
+}
+/**
+* The Bevy file's survey columns from a meeting's `responses` rows: each
+* mapped question anyone answered, and each person's answer in words.
+*/
+function bevySurvey(rows) {
+	const columns = [];
+	const byUser = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const column = row.definition?.bevy;
+		if (!column) continue;
+		if (!columns.includes(column)) columns.push(column);
+		const id = text$1(row.user_id);
+		const answers = byUser.get(id) ?? /* @__PURE__ */ new Map();
+		answers.set(column, text$1(row.answer));
+		byUser.set(id, answers);
+	}
+	return {
+		columns: columns.sort(),
+		byUser
+	};
+}
+//#endregion
+//#region src/export/commands.ts
+/**
+* `backstage export <stars|attendance|reflections>`: the platform's CSV
+* downloads, moved here from `/console/exports`.
+*
+*   pnpm backstage export stars --from 2026-08-17 --to 2026-12-12
+*   pnpm backstage export attendance --meeting 2026-09-09 --format bevy,involvement
+*   pnpm backstage export attendance --meeting 2026-09-09 --out -
+*
+* ## Audited, as the downloads were
+*
+* Each export writes a `platform.exportAudit` row BEFORE the first row is
+* read, as the web routes did: an export that fails halfway still put rows
+* in front of somebody. The row names the officer's platform account, found
+* through the GitHub login `gh` is signed in as (the identity they linked on
+* the platform), so an export nobody can attribute is refused rather than
+* recorded as nobody's. The row count is filled in when the file is done.
+*
+* ## Formats
+*
+* Attendance can be written as the platform CSV, a Bevy attendee import, an
+* Involvement Network email list, or several at once from one read (see
+* `formats.ts`); `--format`, else asked at a terminal, else the platform CSV.
+* Each file gets its own audit row, its format in the filters.
+*
+* ## The files
+*
+* At a terminal, each file's destination is asked for, with path completion
+* (`production/save-path.ts`), suggesting `<kind>[-<meeting>][-<from>][-<to>]
+* [-<format>].<ext>`. Without one, that name in the working directory.
+* `--out` names the file, or a folder for them all; `--out -` streams one
+* export to stdout without the byte-order mark, for a pipe. Files are created
+* readable by their owner only (they are member PII), never over an existing
+* file unless `--yes` or the prompt's own question says so. A failure partway
+* removes every partial file.
+*
+* `--from`/`--to` take Eastern days, `--to` inclusive (see `production/time.ts`).
+*/
+function parse(argv) {
+	const [kind, ...rest] = argv;
+	if (!kind || !EXPORT_KINDS.includes(kind)) throw new UsageError(kind ? `Unknown export "${kind}". Try ${EXPORT_KINDS.join(", ")}.` : `Name the export: ${EXPORT_KINDS.join(", ")}.`);
+	try {
+		const { values } = parseArgs({
+			args: rest,
+			options: {
+				from: { type: "string" },
+				to: { type: "string" },
+				meeting: { type: "string" },
+				format: {
+					type: "string",
+					multiple: true
+				},
+				out: { type: "string" },
+				yes: { type: "boolean" },
+				"dry-run": { type: "boolean" }
+			},
+			allowPositionals: false,
+			strict: true
+		});
+		if (values.meeting && kind !== "attendance" && kind !== "responses") throw new UsageError("--meeting only applies to the attendance and responses exports.");
+		return {
+			kind,
+			values
+		};
+	} catch (err) {
+		if (err instanceof UsageError) throw err;
+		throw new UsageError(errorMessage(err));
+	}
+}
+const run = promisify(execFile);
+/** The GitHub login `gh` is signed in as. */
+async function ghLogin() {
+	try {
+		const { stdout } = await run("gh", [
+			"api",
+			"user",
+			"--jq",
+			".login"
+		]);
+		const login = stdout.trim();
+		if (login) return login;
+	} catch {}
+	throw new ProductionError("Exports are audited under your GitHub login, and `gh` could not say who you are. Install it from https://cli.github.com and run `gh auth login`.");
+}
+const OFFICER_QUERY = `
+select distinct i."user_id"::text as "userId"
+from "auth"."identities" i
+where i."provider" = 'github'
+  and lower(i."identity_data" ->> 'user_name') = lower($1)
+`;
+function sourceWith(sql) {
+	return {
+		officersFor: async (login) => (await sql.unsafe(OFFICER_QUERY, [login])).map((r) => String(r.userId)),
+		findMeetings: findMeetingsWith(sql),
+		audit: async (userId, kind, filters) => {
+			const [row] = await sql.unsafe(`insert into "platform"."exportAudit" ("userId", "kind", "filters")
+         values ($1, $2, $3::text::jsonb) returning "id"::text as "id"`, [
+				userId,
+				kind,
+				JSON.stringify(filters)
+			]);
+			return String(row.id);
+		},
+		rows: async function* (kind, filters) {
+			const { sql: query, transform } = EXPORTS[kind];
+			for await (const page of sql.unsafe(query, exportParams(filters)).cursor(500)) yield transform ? page.map(transform) : page;
+		},
+		finish: async (auditId, rowCount) => {
+			await sql.unsafe(`update "platform"."exportAudit" set "rowCount" = $1 where "id" = $2::uuid`, [rowCount, auditId]);
+		},
+		close: () => sql.end({ timeout: 5 })
+	};
+}
+async function productionSource() {
+	return sourceWith(connect(await requireProductionKey("DB_URL")));
+}
+async function fileSink(path, overwrite, bom) {
+	if (path === "-") return {
+		write: (text) => new Promise((resolve, reject) => process.stdout.write(text, (err) => err ? reject(err) : resolve())),
+		close: () => Promise.resolve(),
+		discard: () => Promise.resolve()
+	};
+	let handle;
+	try {
+		handle = await open(path, overwrite ? "w" : "wx", 384);
+	} catch (err) {
+		if (err.code === "EEXIST") throw new UsageError(`${path} already exists. Pass --yes to replace it.`);
+		throw new UsageError(`Could not write ${path}.`);
+	}
+	if (bom) await handle.write("");
+	return {
+		write: async (text) => {
+			await handle.write(text);
+		},
+		close: () => handle.close(),
+		discard: async () => {
+			await handle.close().catch(() => void 0);
+			await rm(path, { force: true });
+		}
+	};
+}
+function defaultName(kind, values, format, meetingSlug) {
+	const parts = [kind];
+	if (meetingSlug) parts.push(meetingSlug);
+	if (values.from) parts.push(values.from.slice(0, 10));
+	if (values.to) parts.push(values.to.slice(0, 10));
+	if (format.suffix) parts.push(format.suffix);
+	return `${parts.join("-")}.${format.extension}`;
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function pickFormats(kind) {
+	return unwrap(await multiselect({
+		message: "Which formats? (space to choose, enter to export)",
+		options: FORMATS_BY_KIND[kind].map((name) => {
+			const format = formatFor(name, []);
+			return {
+				value: name,
+				label: format.label,
+				hint: format.hint
+			};
+		}),
+		initialValues: ["platform"],
+		required: true
+	}));
+}
+async function askMeeting() {
+	return unwrap(await text({
+		message: "Which meeting? Its day, slug or id.",
+		placeholder: "2026-09-09",
+		validate: (v) => v?.trim() ? void 0 : "A meeting, please."
+	})).trim();
+}
+async function askPath(message, suggested) {
+	return askSavePath({
+		message,
+		suggested
+	});
+}
+/**
+* Where each file goes: `--out` (a file, `-`, or a folder for them all), else
+* asked at a terminal, else its default name here.
+*/
+async function planFiles(formats, name, values, interactive, ask) {
+	const overwrite = values.yes === true;
+	const out = values.out === void 0 ? void 0 : expandHome(values.out);
+	if (out !== void 0 && !isDirectory(out)) {
+		if (formats.length > 1) throw new UsageError(out === "-" ? "--out - streams one export; choose one --format." : "--out names one file; for several formats, give it a folder.");
+		return [{
+			format: formats[0],
+			path: out,
+			overwrite
+		}];
+	}
+	const planned = [];
+	for (const format of formats) if (out !== void 0) planned.push({
+		format,
+		path: join(out, name(format)),
+		overwrite
+	});
+	else if (interactive) {
+		const path = await ask(`Save the ${format.label} to`, name(format));
+		planned.push({
+			format,
+			path,
+			overwrite: true
+		});
+	} else planned.push({
+		format,
+		path: name(format),
+		overwrite
+	});
+	return planned;
+}
+const shown = (path) => path === "-" ? "stdout" : path;
+/** " as Bevy attendee import"; nothing for the platform CSV, the default. */
+const as = (format) => format.name === "platform" ? "" : ` as ${format.label}`;
+async function runExport(argv, deps = {}) {
+	let source;
+	const sinks = [];
+	let done = false;
+	try {
+		const { kind, values } = parse(argv);
+		const filters = {
+			from: parseBound("--from", values.from),
+			to: parseBound("--to", values.to)
+		};
+		if (filters.from && filters.to && filters.from >= filters.to) throw new UsageError("--from must come before --to.");
+		const interactive = deps.interactive ?? canPrompt();
+		let names;
+		try {
+			names = values.format ? parseFormats(values.format, kind) : [];
+		} catch (err) {
+			throw new UsageError(errorMessage(err));
+		}
+		if (names.length === 0) names = FORMATS_BY_KIND[kind].length > 1 && interactive ? await (deps.pickFormats ?? pickFormats)(kind) : ["platform"];
+		const { columns } = EXPORTS[kind];
+		let formats = names.map((n) => formatFor(n, columns));
+		const perEvent = formats.filter((f) => f.perEvent);
+		if (perEvent.length > 0 && !values.meeting) {
+			if (!interactive) throw new UsageError(`The ${perEvent.map((f) => f.label).join(" and ")} ${perEvent.length === 1 ? "file is" : "files are"} for one meeting; name it with --meeting.`);
+			values.meeting = await (deps.askMeeting ?? askMeeting)();
+		}
+		const login = await (deps.ghLogin ?? ghLogin)();
+		source = await (deps.source ?? productionSource)();
+		const officers = await source.officersFor(login);
+		if (officers.length !== 1) throw new ProductionError(officers.length === 0 ? `No platform account has linked the GitHub login ${login}. Link GitHub on your platform profile, then export again.` : `${plural(officers.length, "platform account")} linked the GitHub login ${login}; an export must be attributable to one.`);
+		let slug;
+		if (values.meeting) {
+			const meeting = pickMeeting(values.meeting, await source.findMeetings(values.meeting));
+			filters.meetingId = meeting.id;
+			slug = meeting.slug;
+			say(`Meeting: ${describeMeeting(meeting)}.`);
+		}
+		if (names.includes("bevy") && filters.meetingId) {
+			const answers = [];
+			for await (const page of source.rows("responses", { meetingId: filters.meetingId })) answers.push(...page);
+			const survey = bevySurvey(answers);
+			formats = formats.map((f) => f.name === "bevy" ? bevyFormat(survey) : f);
+		}
+		const files = await planFiles(formats, (format) => defaultName(kind, values, format, slug), values, interactive, deps.askPath ?? askPath);
+		if (values["dry-run"] === true || isDryRun()) {
+			for (const file of files) say(`Would export ${kind}${as(file.format)} to ${shown(file.path)}, audited as ${login}.`);
+			return;
+		}
+		const open = deps.sink ?? fileSink;
+		const writing = [];
+		for (const file of files) {
+			const sink = await open(file.path, file.overwrite, file.format.bom && file.path !== "-");
+			sinks.push(sink);
+			const recorded = auditFilters(filters);
+			if (file.format.name !== "platform") recorded.format = file.format.name;
+			writing.push({
+				file,
+				sink,
+				writer: file.format.writer(),
+				auditId: await source.audit(officers[0], kind, recorded),
+				count: 0
+			});
+		}
+		for (const w of writing) if (w.file.format.head) await w.sink.write(w.file.format.head);
+		for await (const page of source.rows(kind, filters)) for (const w of writing) {
+			const { text, count } = w.writer.page(page);
+			if (text) await w.sink.write(text);
+			w.count += count;
+		}
+		for (const w of writing) {
+			const last = w.writer.end?.();
+			if (last?.text) await w.sink.write(last.text);
+			w.count += last?.count ?? 0;
+			await w.sink.close();
+		}
+		done = true;
+		for (const w of writing) {
+			await source.finish(w.auditId, w.count);
+			const [one, many] = w.file.format.unit;
+			say(`Wrote ${plural(w.count, one, many)}${as(w.file.format)} to ${shown(w.file.path)}.`, "success");
+			const skipped = w.writer.skipped();
+			if (skipped > 0) say(`${plural(skipped, "attendee")} without ${w.file.format.needs} on file ${skipped === 1 ? "is" : "are"} not in ${shown(w.file.path)}.`, "warn");
+		}
+	} catch (err) {
+		if (!done) await Promise.all(sinks.map((s) => s.discard().catch(() => void 0)));
+		const worded = err instanceof UsageError || err instanceof ProductionError ? err : err.code ? dbError("The export failed", err) : err;
+		reportFailure("export", worded);
+	} finally {
+		await source?.close().catch(() => void 0);
+	}
+}
+const handleExport = async (rest) => {
+	await runExport(rest);
+	return process.exitCode ? null : DONE;
+};
+//#endregion
+export { handleExport };