@devdogsuga/devtools 0.1.0

package/dist/help.js

@@ -0,0 +1,169 @@
+/**
+ * `--help`, one level at a time.
+ *
+ * ## Why this is small
+ *
+ * The help this replaced was ~200 lines and printed the whole tree: every
+ * subcommand of every group, the Bitwarden target table, the four places an
+ * access token is looked for, the grants `migration_planner` holds, and which
+ * deploy steps must avoid the `with-env` wrapper. A contributor running
+ * `pnpm devtools --help` to find out how to start a database read all of it.
+ *
+ * Two rules now:
+ *
+ *   1. **A level prints its own children and stops.** `--help` lists the
+ *      top-level commands; `env --help` lists env's subcommands; `env pull
+ *      --help` lists that command's options. Depth is reached by asking for
+ *      it.
+ *   2. **No more than the caller needs to choose.** Operator internals are
+ *      `docs/`'s job: which project a target maps to, how a credential is
+ *      resolved, what a deploy job's environment holds. Help says what a
+ *      command does and what it takes.
+ *
+ * Both fall out of rendering `commands.ts` rather than hand-writing prose, so
+ * neither can rot back into a wall of text one paragraph at a time.
+ */
+import { findCommand, GROUPS, SCOPES, } from "./commands.js";
+const INDENT = "  ";
+/** `--target <t>`, or `--prune` for a boolean. */
+function optionLabel(option) {
+    return option.value ? `${option.flag} ${option.value}` : option.flag;
+}
+/**
+ * Two columns, with the gutter sized to the widest label in THIS block.
+ *
+ * Per-block rather than one width for the whole file: `deploy`'s labels are
+ * long and `setup`'s are not, and a shared width would indent the short list
+ * halfway across the terminal to accommodate a group the reader is not
+ * looking at.
+ */
+function columns(rows) {
+    const width = Math.max(...rows.map(([label]) => label.length));
+    return rows.map(([label, text]) => `${INDENT}${label.padEnd(width)}  ${text}`);
+}
+/**
+ * A list of commands, split into scope blocks when any of them declares one.
+ *
+ * Used at two levels: a GROUP's own commands (no group has scoped commands
+ * today — `db` folded the old "Supabase" group's scopes into itself), and a
+ * command's own SUBCOMMANDS (`db`'s: `start`/`connect`/`stop`/`restart` on
+ * this machine, `migration` in the repo, `status`/`migrate`/`reset`/… on an
+ * endpoint, `planner`/`signing-key` naming their own connection). Either way,
+ * a flat list leaves the reader to work out which of `restart` and `reset` is
+ * which, the distinction that costs people an afternoon. A list with no
+ * scopes renders as it always did: one block, one indent, no headings.
+ *
+ * The blocks follow declaration order rather than `SCOPES` order, so the tree
+ * stays the one place that decides how the list reads. The gutter is sized
+ * across the whole list, not per block, so every block lines up with the
+ * others rather than each finding its own column.
+ */
+function scopedBody(commands) {
+    if (!commands.some((command) => command.scope)) {
+        return columns(childRows(commands));
+    }
+    const width = Math.max(...commands.map((command) => command.name.length));
+    const lines = [];
+    let open;
+    for (const command of commands) {
+        if (command.scope && command.scope !== open) {
+            open = command.scope;
+            lines.push(`${INDENT}${SCOPES[open].help}:`);
+        }
+        lines.push(`${INDENT.repeat(2)}${command.name.padEnd(width)}  ${command.summary}`);
+    }
+    return lines;
+}
+function optionRows(options) {
+    return options.map((option) => [optionLabel(option), option.summary]);
+}
+function childRows(children) {
+    return children.map((child) => [child.name, child.summary]);
+}
+// ── The three levels ─────────────────────────────────────────────────────────
+/** `pnpm devtools --help`: the groups, and nothing below them. */
+function renderRoot() {
+    const lines = [
+        "pnpm devtools [command] [options]",
+        "",
+        "Run with no command to choose from a menu.",
+        "",
+        "Common tasks:",
+        ...columns([
+            ["setup", "Prepare a new checkout"],
+            ["run dev", "Start development servers"],
+            ["db start", "Start Supabase on this machine"],
+            ["db reset", "Rebuild the local database"],
+            ["cron run", "Choose and run a scheduled job"],
+        ]),
+    ];
+    for (const group of GROUPS) {
+        lines.push("", `${group.title}:`, ...scopedBody(group.commands));
+    }
+    lines.push("", "Options:", ...columns([
+        ["--help, -h", "Show this message"],
+        [
+            "--tier <t>",
+            "Deploy tier for this whole invocation (development, staging, production)",
+        ],
+    ]), "", "`pnpm devtools <command> --help` shows what that command takes.");
+    return lines.join("\n");
+}
+/** `pnpm devtools <path…> --help`: one command's own children and options. */
+function renderCommand(path, node) {
+    const children = node.subcommands ?? [];
+    const options = node.options ?? [];
+    const trail = path.join(" ");
+    const usage = [
+        "pnpm devtools",
+        trail,
+        children.length > 0 ? "<subcommand>" : "",
+        options.length > 0 ? "[options]" : "",
+    ]
+        .filter(Boolean)
+        .join(" ");
+    const lines = [usage, "", node.summary];
+    if (children.length > 0) {
+        lines.push("", "Subcommands:", ...scopedBody(children));
+    }
+    if (options.length > 0) {
+        lines.push("", "Options:", ...columns(optionRows(options)));
+    }
+    if (children.length > 0) {
+        lines.push("", `\`pnpm devtools ${trail} <subcommand> --help\` shows what that one takes.`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Renders help for a path, falling back to the root.
+ *
+ * An unknown path renders the root rather than an error: this is only reached
+ * when `--help` was asked for, and answering a mistyped command with the list
+ * it was mistyped from is more use than a refusal.
+ */
+export function renderHelp(path = []) {
+    if (path.length === 0)
+        return renderRoot();
+    const node = findCommand(path);
+    if (!node)
+        return renderRoot();
+    return renderCommand(path, node);
+}
+/**
+ * The command names in `argv` that precede any flag.
+ *
+ * `env pull --help` asks about `["env", "pull"]`; `--help env` asks about
+ * nothing, because a flag's value is not a command path. Kept separate from
+ * `positionals()`: that one strips a known set of value-taking flags to find a
+ * subcommand, and here anything after the first flag is not part of the path at
+ * all.
+ */
+export function helpPath(argv) {
+    const path = [];
+    for (const arg of argv) {
+        if (arg.startsWith("-"))
+            break;
+        path.push(arg);
+    }
+    return path;
+}

package/dist/images/commands.d.ts

@@ -0,0 +1,35 @@
+import type { Format } from "./open-graph-types.js";
+import { type Instance } from "../instance.js";
+import { type EventReader } from "./events.js";
+import { type Selection } from "./select.js";
+export interface ImagesOptions {
+    /** Graphic patterns. Empty means ask. */
+    patterns: string[];
+    /** Format names. Empty with `allFormats` false means ask. */
+    formats: string[];
+    allFormats: boolean;
+    /** An explicit directory; everything lands in it, flat. */
+    out?: string;
+    /** Use each graphic's own default directory. */
+    defaultOut: boolean;
+    /** List what would be written, and write nothing. */
+    noOutput: boolean;
+}
+export declare function parseImagesArgs(argv: readonly string[]): ImagesOptions;
+/** `~/images` when the shell did not expand it, which quoting prevents. */
+export declare function expandHome(path: string): string;
+/** Whether anything asked for could be an event, so whether to reach for a database. */
+export declare function wantsEvents(patterns: readonly string[]): boolean;
+/** Whether a pattern names events specifically, rather than sweeping them up. */
+export declare function namesEvents(patterns: readonly string[]): boolean;
+export interface ImagesDeps {
+    /** Resolves the database, printing its own diagnosis on failure. */
+    connect: () => Promise<Instance | null>;
+    /** Overridden in tests so nothing opens a socket. */
+    reader?: (instance: Instance) => EventReader;
+}
+/** Where one selection is written. */
+export declare function destinationOf({ graphic, format }: Selection, out: string | undefined): string;
+export declare function runImages(argv: string[], deps: ImagesDeps): Promise<void>;
+/** Re-exported so `render.ts`'s options type is the format's own shape. */
+export type { Format };

package/dist/images/commands.js

@@ -0,0 +1,233 @@
+/**
+ * `pnpm devtools images [graphic…] [--format …] [--out …]`
+ *
+ * Renders the club's pictures from the templates in `@devdogsuga/open-graph`. Two axes,
+ * asked for separately: WHICH picture (`event/2026-09-08`, `page/events`,
+ * `app/dogdays`) and at WHAT SIZE (`gdgc-square`, `og`, `icon-512`). That split
+ * is the point of the command — an event poster for the GDG on Campus platform
+ * is exactly the pairing "this meeting" x "that platform's banner", and it
+ * could not be asked for while the two were one hard-coded list.
+ *
+ * Anything the command line leaves out, it asks for; anything it names, it does
+ * not. So an officer can type `pnpm devtools images` and be walked through it,
+ * and a script can pass every flag and never see a prompt.
+ *
+ * Event graphics are the one group backed by a database rather than by files in
+ * this repo, and the one group that can therefore be unavailable. See
+ * {@link loadEvents} for what the command says when it is.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { log, note } from "@clack/prompts";
+import { loadOpenGraph } from "../repo/source.js";
+import { findRepoRoot } from "../repo/root.js";
+import { positionals } from "../args.js";
+import { adminClient } from "../instance.js";
+import { errorMessage, explain } from "../ui.js";
+import { supabaseEvents } from "./events.js";
+import { assertUniqueStems, eventGraphics, staticGraphics, } from "./graphics.js";
+import { pickFormats, pickGraphics, pickOutput } from "./prompts.js";
+import { render } from "./render.js";
+import { commaList, formatsFor, matchGraphics, normalizeArgv, pair, } from "./select.js";
+/**
+ * The workspace root. Every default directory is written relative to it, and
+ * resolving those against `process.cwd()` would put the club's icons wherever
+ * the contributor happened to be standing.
+ */
+function flagValue(argv, flag) {
+    const index = argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    const value = argv[index + 1];
+    return value && !value.startsWith("--") ? value : undefined;
+}
+export function parseImagesArgs(argv) {
+    const normalized = normalizeArgv(argv);
+    return {
+        patterns: positionals(normalized),
+        formats: commaList(flagValue(normalized, "--format")),
+        allFormats: normalized.includes("--all-formats"),
+        out: flagValue(normalized, "--out"),
+        defaultOut: normalized.includes("--default-out"),
+        noOutput: normalized.includes("--dry-run") || normalized.includes("--no-output"),
+    };
+}
+/** `~/images` when the shell did not expand it, which quoting prevents. */
+export function expandHome(path) {
+    return path === "~" || path.startsWith("~/")
+        ? resolve(homedir(), path.slice(2))
+        : path;
+}
+/** Whether anything asked for could be an event, so whether to reach for a database. */
+export function wantsEvents(patterns) {
+    // No pattern means the picker, and the picker should list meetings.
+    if (patterns.length === 0)
+        return true;
+    return patterns.some((pattern) => pattern === "*" ||
+        pattern === "*/*" ||
+        pattern === "event" ||
+        pattern.startsWith("event/"));
+}
+/** Whether a pattern names events specifically, rather than sweeping them up. */
+export function namesEvents(patterns) {
+    return patterns.some((pattern) => pattern === "event" || pattern.startsWith("event/"));
+}
+/**
+ * Meetings, or a clear account of why there are none.
+ *
+ * The database is the one dependency of this command that a contributor cannot
+ * see, so every failure here says which database it looked at and what to run.
+ * Two failures, treated differently, matching what each one means:
+ *
+ *   - **Unreachable, under a wildcard.** `images *` means "everything", and
+ *     everything else is renderable. It renders, and reports the events it
+ *     could not.
+ *   - **Unreachable, named.** `images 'event/*'` asked for exactly the thing
+ *     that is missing. Nothing to degrade to, so it fails.
+ */
+async function loadEvents(patterns, deps) {
+    const required = namesEvents(patterns);
+    const instance = await deps.connect();
+    if (!instance) {
+        if (required) {
+            throw new Error("Event images come from the database, and there is no database to read.");
+        }
+        return {
+            graphics: [],
+            skipped: "no database reachable — run `pnpm devtools db start`",
+        };
+    }
+    const reader = (deps.reader ?? ((i) => supabaseEvents(adminClient(i))))(instance);
+    let meetings;
+    try {
+        meetings = await reader.meetings();
+    }
+    catch (err) {
+        if (required)
+            throw err;
+        return { graphics: [], skipped: errorMessage(err) };
+    }
+    return { graphics: eventGraphics(await loadOpenGraph(), meetings), skipped: null };
+}
+/** Where one selection is written. */
+export function destinationOf({ graphic, format }, out) {
+    if (out) {
+        // Flat, and always `<stem>-<format>.png`: the pinned filenames a graphic
+        // uses in its own directory (`icon.png`, `opengraph-image.png`) are only
+        // unambiguous BECAUSE the directories differ. Side by side they collide.
+        return resolve(expandHome(out), `${graphic.stem}-${format.name}.png`);
+    }
+    const { dir, file } = graphic.destination(format);
+    return resolve(findRepoRoot(), dir, file);
+}
+/** Repo-relative where possible, so the log reads as paths in this project. */
+function display(file) {
+    const rel = relative(findRepoRoot(), file);
+    return rel.startsWith("..") || isAbsolute(rel) ? file : rel;
+}
+export async function runImages(argv, deps) {
+    const options = parseImagesArgs(argv);
+    if (options.out && options.defaultOut) {
+        explain("Two answers to one question.", "--out names a directory and --default-out says to use each graphic's own.", [
+            "pnpm devtools images 'event/*' --out ~/images",
+            "pnpm devtools images '*' --default-out",
+        ]);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        await images(options, deps);
+    }
+    catch (err) {
+        explain("Could not render that.", errorMessage(err), [
+            "pnpm devtools images                      # pick from a list",
+            "pnpm devtools images 'event/*' --all-formats --out ~/images",
+            "pnpm devtools images '*' --default-out",
+        ]);
+        process.exitCode = 1;
+    }
+}
+async function images(options, deps) {
+    // ── Which pictures ────────────────────────────────────────────────────────
+    const registry = await staticGraphics();
+    let skipped = null;
+    if (wantsEvents(options.patterns)) {
+        const events = await loadEvents(options.patterns, deps);
+        registry.push(...events.graphics);
+        skipped = events.skipped;
+    }
+    assertUniqueStems(registry);
+    const graphics = options.patterns.length === 0
+        ? await pickGraphics(registry)
+        : resolvePatterns(options.patterns, registry);
+    if (graphics.length === 0) {
+        throw new Error("Nothing to render.");
+    }
+    // ── At what sizes ─────────────────────────────────────────────────────────
+    const { FORMATS } = await loadOpenGraph();
+    const requested = options.allFormats
+        ? (await formatsFor(graphics)).map((format) => format.name)
+        : options.formats.length > 0
+            ? options.formats
+            : await pickFormats(graphics);
+    const unknown = requested.filter((name) => !FORMATS[name]);
+    if (unknown.length > 0) {
+        throw new Error(`No format called ${unknown.join(", ")}. Try one of ${Object.keys(FORMATS).join(", ")}.`);
+    }
+    const { selections, unsupported } = await pair(graphics, requested);
+    // Naming one graphic and one format it cannot do is a mistake worth saying
+    // out loud; sweeping up combinations that do not exist under a wildcard is
+    // not, and reporting every one of those would bury the output.
+    if (selections.length === 0 && unsupported.length > 0) {
+        throw new Error(unsupported
+            .map((miss) => `${miss.graphic} has no ${miss.format} rendition`)
+            .join("; "));
+    }
+    if (selections.length === 0)
+        throw new Error("Nothing to render.");
+    // ── Where ─────────────────────────────────────────────────────────────────
+    const out = options.defaultOut
+        ? undefined
+        : options.out
+            ? options.out
+            : options.noOutput
+                ? undefined
+                : await pickOutput(graphics);
+    if (skipped)
+        log.warn(`event graphics skipped — ${skipped}`);
+    if (options.noOutput) {
+        note(selections
+            .map((selection) => `${selection.graphic.name}  ${selection.format.name}\n  ${display(destinationOf(selection, out))}\n  ${selection.format.why}`)
+            .join("\n"), `${selections.length} image${selections.length === 1 ? "" : "s"}`);
+        return;
+    }
+    // ── Render ────────────────────────────────────────────────────────────────
+    let bytes = 0;
+    for (const selection of selections) {
+        const file = destinationOf(selection, out);
+        const { png, width, height } = await render(selection.graphic.render(selection.format), selection.format);
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, png);
+        bytes += png.length;
+        log.success(`${display(file)}  ${width}x${height}  (${Math.round(png.length / 1024)} KB)`);
+    }
+    log.info(`${selections.length} image${selections.length === 1 ? "" : "s"}, ${Math.round(bytes / 1024)} KB total.`);
+}
+function resolvePatterns(patterns, registry) {
+    const { matched, unmatched } = matchGraphics(patterns, registry);
+    if (unmatched.length === 0)
+        return matched;
+    // An event pattern that matched nothing is almost never a typo — it is a
+    // database with no meetings in it. Saying "try brand/*, page/*" sends the
+    // reader hunting for a spelling mistake that is not there.
+    const askedForEvents = unmatched.some((pattern) => pattern === "event" || pattern.startsWith("event/"));
+    const haveEvents = registry.some((graphic) => graphic.group === "event");
+    if (askedForEvents && !haveEvents) {
+        throw new Error("This database has no meetings, so there are no event images to render. " +
+            "Reconcile it from `@devdogsuga/events`, or point at a database that has been.");
+    }
+    const groups = [...new Set(registry.map((graphic) => `${graphic.group}/*`))];
+    throw new Error(`Nothing called ${unmatched.join(", ")}. Names are group/name — try ` +
+        `${groups.join(", ")}, or * for all of them.`);
+}

package/dist/images/events.d.ts

@@ -0,0 +1,36 @@
+import type { DevtoolsClient } from "../instance.js";
+import type { EventGraphicSource } from "./graphics.js";
+/**
+ * Meetings, for the one group of graphics that cannot be drawn from the repo.
+ *
+ * Every other graphic is a function of committed files. An event poster is a
+ * function of meetings reconciled into the database from
+ * `@devdogsuga/events`, so `devtools images event/*` needs a running
+ * database that has that config loaded into it — and there is nothing about
+ * typing a command that makes that obvious. Making it obvious is most of what
+ * this file is for: the reads are small, and {@link EventReader} is the seam
+ * the command talks to, so tests never open a socket.
+ *
+ * Reads go through `adminClient`, against the local instance resolved by the
+ * command. `platform` is exposed to PostgREST (`supabase/config.toml`),
+ * and the service role bypasses the RLS that otherwise keeps `meetings` and
+ * `workshops` closed to every client.
+ */
+/** The seam the command talks to, so tests never open a socket. */
+export interface EventReader {
+    meetings(): Promise<EventGraphicSource[]>;
+}
+export declare function supabaseEvents(client: DevtoolsClient): EventReader;
+/**
+ * The meeting's name, in descending order of how much somebody meant it.
+ *
+ * Mirrors `apps/platform/src/lib/meetingTitle.ts`: an authored name, then the
+ * kind, then the workshops it teaches, then the date. Two named workshops read
+ * as a heading; three do not, and the date carries it while the agenda below
+ * shows the detail.
+ *
+ * Duplicated rather than imported because it lives in the Next app, which this
+ * package cannot depend on. `events.test.ts` pins the chain so a change to one
+ * shows up as a failure rather than as a differently-titled poster.
+ */
+export declare function meetingTitle(nameOverride: string | null, kind: string | null, startsAt: Date, agenda: readonly string[]): string;

package/dist/images/events.js

@@ -0,0 +1,152 @@
+import { loadBrandEvent } from "../repo/peers.js";
+export function supabaseEvents(client) {
+    return {
+        async meetings() {
+            // Cancelled nights are included deliberately: a cancellation is exactly
+            // when somebody needs a fresh graphic, and the card has a layout for it.
+            // Deleted ones are not.
+            //
+            // No competitions query any more: a competition is a mirrored GitHub
+            // issue now (see apps/platform/src/server/github/competitions.ts), not
+            // something a meeting kicks off or judges, so there is no "kickoff" or
+            // "judging" segment left for a meeting poster to draw. Every workshop
+            // item is plain "workshop".
+            const [meetings, workshops] = await Promise.all([
+                client
+                    .from("meetings")
+                    .select("id, slug, nameOverride, kind, building, location, startsAt, endsAt, cancelledAt, cancellationReason")
+                    .is("deletedAt", null)
+                    .order("startsAt", { ascending: false }),
+                client
+                    .from("workshops")
+                    .select("id, meetingId, title, projects(displayName, sortOrder)")
+                    .is("deletedAt", null),
+            ]);
+            if (meetings.error)
+                throw new Error(`Could not read meetings: ${meetings.error.message}`);
+            if (workshops.error) {
+                throw new Error(`Could not read workshops: ${workshops.error.message}`);
+            }
+            const workshopRows = (workshops.data ?? []);
+            const agendas = groupAgendas(workshopRows);
+            const { EVENT_SEGMENT_VISUALS, meetingCardDetail, meetingLocation } = await loadBrandEvent();
+            return (meetings.data ?? []).map((row) => {
+                const agenda = agendas.get(row.id) ?? [];
+                const meeting = {
+                    slug: row.slug,
+                    startsAt: new Date(row.startsAt),
+                    endsAt: new Date(row.endsAt),
+                    building: row.building,
+                    location: row.location,
+                    kind: row.kind,
+                    cancelledAt: row.cancelledAt ? new Date(row.cancelledAt) : null,
+                    cancellationReason: row.cancellationReason,
+                };
+                const items = workshopRows
+                    .filter((workshop) => workshop.meetingId === row.id)
+                    .map((workshop) => ({
+                    label: workshopLabel(workshop),
+                    segment: "workshop",
+                }));
+                const detail = meetingCardDetail({
+                    meeting,
+                    title: meetingTitle(row.nameOverride, row.kind, meeting.startsAt, agenda),
+                    agenda: items.map((item) => `${EVENT_SEGMENT_VISUALS[item.segment].label}: ${item.label}`),
+                    location: meetingLocation(row.building, row.location),
+                });
+                return {
+                    slug: row.slug,
+                    hint: describeMeeting(meeting),
+                    detail,
+                    items: items.map((item) => {
+                        const visual = EVENT_SEGMENT_VISUALS[item.segment];
+                        return {
+                            stem: slugPart(item.label),
+                            detail: {
+                                ...detail,
+                                title: item.label,
+                                agenda: undefined,
+                                badge: { label: visual.label, accent: visual.accent },
+                            },
+                        };
+                    }),
+                };
+            });
+        },
+    };
+}
+/** A readable path component for a workshop card. */
+function slugPart(label) {
+    return (label
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "") || "agenda-item");
+}
+function workshopLabel(row) {
+    return row.title ?? row.projects?.displayName ?? "Workshop";
+}
+/**
+ * Workshop labels per meeting, in the order the app shows them.
+ *
+ * `projects.sortOrder` first, then the project's name, then the workshop's own
+ * title — the ordering `getMeetingWorkshops` uses, so an agenda here reads the
+ * same way it does on the page. A workshop with no project keeps its own title
+ * and sorts last, which is what `nulls last` does there.
+ */
+function groupAgendas(rows) {
+    const byMeeting = new Map();
+    for (const row of rows) {
+        const list = byMeeting.get(row.meetingId) ?? [];
+        list.push(row);
+        byMeeting.set(row.meetingId, list);
+    }
+    const agendas = new Map();
+    for (const [meetingId, list] of byMeeting) {
+        const labels = list
+            .sort((a, b) => {
+            const order = (a.projects?.sortOrder ?? Number.MAX_SAFE_INTEGER) -
+                (b.projects?.sortOrder ?? Number.MAX_SAFE_INTEGER);
+            if (order !== 0)
+                return order;
+            return ((a.projects?.displayName ?? "").localeCompare(b.projects?.displayName ?? "") || (a.title ?? "").localeCompare(b.title ?? ""));
+        })
+            .map(workshopLabel);
+        agendas.set(meetingId, labels);
+    }
+    return agendas;
+}
+/**
+ * The meeting's name, in descending order of how much somebody meant it.
+ *
+ * Mirrors `apps/platform/src/lib/meetingTitle.ts`: an authored name, then the
+ * kind, then the workshops it teaches, then the date. Two named workshops read
+ * as a heading; three do not, and the date carries it while the agenda below
+ * shows the detail.
+ *
+ * Duplicated rather than imported because it lives in the Next app, which this
+ * package cannot depend on. `events.test.ts` pins the chain so a change to one
+ * shows up as a failure rather than as a differently-titled poster.
+ */
+export function meetingTitle(nameOverride, kind, startsAt, agenda) {
+    if (nameOverride !== null)
+        return nameOverride;
+    if (kind !== null)
+        return kind;
+    if (agenda.length === 1)
+        return `Workshop: ${agenda[0]}`;
+    if (agenda.length === 2)
+        return `Workshop: ${agenda[0]} & ${agenda[1]}`;
+    return startsAt.toLocaleDateString("en-US", {
+        timeZone: "America/New_York",
+        dateStyle: "long",
+    });
+}
+/** One line for the picker: when it is, and whether it is still on. */
+function describeMeeting(meeting) {
+    const when = meeting.startsAt.toLocaleDateString("en-US", {
+        timeZone: "America/New_York",
+        dateStyle: "medium",
+    });
+    return meeting.cancelledAt === null ? when : `${when}, cancelled`;
+}