@t09tanaka/stoneage 0.1.0

package/dist/example.js

@@ -0,0 +1,1272 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { performance } from "node:perf_hooks";
+import { fileURLToPath } from "node:url";
+import { writeTailwindUtilitiesCss } from "./assets.js";
+import { buildSite, definePublicDataJsonArtifacts, defineRouteFamily, hashValue, patternParamMatcher, writeNormalizedJsonData, } from "./core.js";
+import { optimizeImages, srcsetFor, } from "./images.js";
+import { pageForItemIndex, paginate } from "./pagination.js";
+import { defineSearchIndexArtifact } from "./search.js";
+const recordHashValueReferences = new WeakMap();
+const exampleCssCandidates = ["w", "m"];
+const exampleBuildConcurrency = 128;
+const exampleFileWalkConcurrency = 64;
+const conversationIndexPageSize = 20;
+const sessionConversationPreviewLimit = 12;
+const exampleSitemapMaxUrlsPerFile = 10_000;
+const fourDigitYear = patternParamMatcher(/^\d{4}$/);
+let exampleRenderFingerprintCache;
+const exampleTailwindCss = `
+@layer base {
+  body {
+    margin: 0;
+    color: #111827;
+    font-family: ui-sans-serif, system-ui, sans-serif;
+  }
+  a {
+    color: #1d4ed8;
+    text-decoration-line: none;
+  }
+  a:hover {
+    text-decoration-line: underline;
+  }
+  h1 {
+    font-size: 1.875rem;
+    font-weight: 600;
+  }
+  h2 {
+    margin-top: 2rem;
+    font-size: 1.25rem;
+    font-weight: 600;
+  }
+  main {
+    max-width: 48rem;
+    margin-inline: auto;
+    padding: 2.5rem 1.5rem;
+  }
+}
+@utility w {
+  max-width: 56rem;
+}
+@utility m {
+  color: #64748b;
+  font-size: .875rem;
+}
+`;
+const defaultCounts = {
+    members: 250,
+    sessions: 80,
+    conversations: 3_000,
+    bills: 600,
+};
+export async function buildExampleSite(options) {
+    const counts = {
+        ...defaultCounts,
+        ...options.counts,
+    };
+    return buildExampleSiteFromData(options, createExampleData(counts));
+}
+async function buildExampleSiteFromData(options, sourceData) {
+    const data = options.mutateConversationId
+        ? dataWithMutatedConversation(sourceData, options.mutateConversationId)
+        : sourceData;
+    const dataHashing = {
+        recordsHashed: 0,
+    };
+    const normalized = await writeExampleNormalizedData(options.outDir, data, dataHashing, options.recordHashCache);
+    const normalizedData = dataFromSnapshots(normalized.snapshots);
+    const partialConversationBuild = Boolean(options.partialConversationId);
+    if (!partialConversationBuild) {
+        await writeSiteCss(options.outDir);
+    }
+    const imageOptimization = partialConversationBuild
+        ? emptyImageOptimization()
+        : await prepareExampleImages(options.outDir, normalizedData.members, {
+            converter: options.imageConverter,
+            loadConverter: options.loadImageConverter,
+        });
+    const paginationSummary = {
+        conversationIndexItemsMaterialized: 0,
+    };
+    const trailingSlash = options.trailingSlash ?? "always";
+    const renderFingerprint = await exampleRenderFingerprint();
+    const buildFingerprint = exampleBuildFingerprint(normalized.snapshots, imageOptimization.variantsByMember, {
+        includePublicDataExports: Boolean(options.includePublicDataExports),
+        sitemapMaxUrlsPerFile: options.sitemapMaxUrlsPerFile ?? exampleSitemapMaxUrlsPerFile,
+        trailingSlash,
+        renderFingerprint,
+    });
+    const result = await buildSite({
+        outDir: options.outDir,
+        buildFingerprint,
+        renderFingerprint,
+        concurrency: exampleBuildConcurrency,
+        partial: Boolean(options.partialConversationId),
+        trailingSlash,
+        site: {
+            baseUrl: "https://example.stoneage.local",
+            title: "StoneAge",
+            description: "A generated public-data archive used to benchmark StoneAge.",
+            openGraph: false,
+        },
+        assets: {
+            stylesheets: ["/s.css"],
+        },
+        prefetch: {
+            serviceWorker: true,
+            linkRel: false,
+            scriptPath: "/p.js",
+            workerPath: "/p-sw.js",
+            cacheName: "stoneage-example-prefetch-v1",
+        },
+        sitemap: {
+            maxUrlsPerFile: options.sitemapMaxUrlsPerFile ?? exampleSitemapMaxUrlsPerFile,
+        },
+        routes: createRoutes(normalizedData, {
+            onlyConversationId: options.partialConversationId,
+            portraitVariants: imageOptimization.variantsByMember,
+            dataHashing,
+            pagination: paginationSummary,
+            trailingSlash,
+            recordHashCache: options.recordHashCache,
+            conversationIndexCache: options.conversationIndexCache,
+        }),
+        artifacts: options.includePublicDataExports
+            ? createPublicDataArtifacts(normalized.snapshots, trailingSlash)
+            : undefined,
+    });
+    return {
+        ...result,
+        imageOptimization: imageOptimization.summary,
+        dataNormalization: normalized.summary,
+        dataHashing,
+        pagination: paginationSummary,
+    };
+}
+function dataFromSnapshots(snapshots) {
+    return {
+        members: snapshots.members.data,
+        sessions: snapshots.sessions.data,
+        conversations: snapshots.conversations.data,
+        bills: snapshots.bills.data,
+        categories: snapshots.categories.data,
+        votes: snapshots.votes.data,
+        yearlyAggregates: snapshots.yearlyAggregates.data,
+    };
+}
+function exampleBuildFingerprint(snapshots, variantsByMember, options) {
+    return hashValue({
+        snapshots: Object.fromEntries(Object.entries(snapshots).map(([key, snapshot]) => [
+            key,
+            {
+                hash: snapshot.hash,
+                bytes: snapshot.bytes,
+            },
+        ])),
+        imageVariants: [...variantsByMember.entries()].map(([memberId, variants]) => [
+            memberId,
+            variants.map((variant) => ({
+                publicPath: variant.publicPath,
+                width: variant.width,
+                format: variant.format,
+                bytes: variant.bytes,
+            })),
+        ]),
+        includePublicDataExports: options.includePublicDataExports,
+        sitemapMaxUrlsPerFile: options.sitemapMaxUrlsPerFile,
+        trailingSlash: options.trailingSlash,
+        renderFingerprint: options.renderFingerprint,
+    });
+}
+async function exampleRenderFingerprint() {
+    if (exampleRenderFingerprintCache !== undefined) {
+        return exampleRenderFingerprintCache;
+    }
+    const moduleSource = await readFile(fileURLToPath(import.meta.url), "utf8");
+    exampleRenderFingerprintCache = hashFingerprint(moduleSource);
+    return exampleRenderFingerprintCache;
+}
+export async function benchmarkExampleSite(options) {
+    await rm(options.outDir, { recursive: true, force: true });
+    const counts = {
+        ...defaultCounts,
+        ...options.counts,
+    };
+    const data = createExampleData(counts);
+    const recordHashCache = new Map();
+    const conversationIndexCache = new Map();
+    const fullStart = performance.now();
+    const full = await buildExampleSiteFromData({ ...options, recordHashCache, conversationIndexCache }, data);
+    const fullBuildMs = performance.now() - fullStart;
+    const incrementalStart = performance.now();
+    const incremental = await buildExampleSiteFromData({
+        ...options,
+        recordHashCache,
+        conversationIndexCache,
+    }, data);
+    const incrementalBuildMs = performance.now() - incrementalStart;
+    const changedStart = performance.now();
+    const changed = await buildExampleSiteFromData({
+        ...options,
+        recordHashCache,
+        conversationIndexCache,
+        mutateConversationId: "conversation-001",
+        partialConversationId: "conversation-001",
+    }, data);
+    const changedBuildMs = performance.now() - changedStart;
+    const outputSizes = await measureExampleOutputSizes(options.outDir, {
+        includePublicDataExports: Boolean(options.includePublicDataExports),
+        knownHtmlOutputBytes: htmlOutputBytesFromManifest(changed.manifest),
+    });
+    const sitemapOutput = await measureSitemapOutput(options.outDir, full.report.sitemapFiles);
+    const largestDependencyFanout = largestDependencyFanoutFromManifest(full.manifest);
+    const metrics = {
+        pageCount: full.report.pageCount,
+        fullBuildMs,
+        incrementalBuildMs,
+        fullBuildPagesWritten: full.pagesWritten,
+        incrementalBuildPagesWritten: incremental.pagesWritten,
+        changedBuildMs,
+        changedBuildPagesWritten: changed.pagesWritten,
+        normalizedDataSnapshots: full.dataNormalization.snapshots,
+        normalizedDataBytes: full.dataNormalization.bytes,
+        fullBuildNormalizedDataWrites: full.dataNormalization.written,
+        incrementalBuildNormalizedDataWrites: incremental.dataNormalization.written,
+        changedBuildNormalizedDataWrites: changed.dataNormalization.written,
+        fullBuildRecordHashes: full.dataHashing.recordsHashed,
+        incrementalBuildRecordHashes: incremental.dataHashing.recordsHashed,
+        changedBuildRecordHashes: changed.dataHashing.recordsHashed,
+        fullBuildConversationIndexItemsMaterialized: full.pagination.conversationIndexItemsMaterialized,
+        incrementalBuildConversationIndexItemsMaterialized: incremental.pagination.conversationIndexItemsMaterialized,
+        changedBuildConversationIndexItemsMaterialized: changed.pagination.conversationIndexItemsMaterialized,
+        ...outputSizes,
+        imageOptimization: full.imageOptimization,
+        largestHtml: full.report.largestHtml,
+        routeFamilies: full.report.routeFamilies,
+        sitemapUrlCount: full.manifest.pages.filter((page) => page.sitemap).length,
+        sitemapFileCount: full.report.sitemapFiles.length,
+        sitemapBytes: sitemapOutput.bytes,
+        largestSitemapBytes: sitemapOutput.largestBytes,
+        missingLinkCount: full.report.missingLinks.length,
+        validationIssueCount: full.report.validation.issues.length,
+        largestDependencyFanout,
+        publicDataRecordCounts: exampleDataRecordCounts(data),
+    };
+    await writeJson(join(options.outDir, ".stoneage/benchmark.json"), metrics);
+    return metrics;
+}
+async function measureSitemapOutput(outDir, files) {
+    const sizes = await Promise.all(files.map(async (file) => (await stat(join(outDir, file))).size));
+    return {
+        bytes: sizes.reduce((sum, bytes) => sum + bytes, 0),
+        largestBytes: sizes.length === 0 ? 0 : Math.max(...sizes),
+    };
+}
+export async function measureExampleOutputSizes(outDir, options = {}) {
+    const sizes = {
+        totalOutputBytes: 0,
+        publicOutputBytes: 0,
+        internalOutputBytes: 0,
+        htmlOutputBytes: 0,
+        cssOutputBytes: 0,
+        jsOutputBytes: 0,
+        imageOutputBytes: 0,
+        dataOutputBytes: 0,
+        averageHtmlBytes: 0,
+        p95HtmlBytes: 0,
+    };
+    const htmlSizes = [];
+    const knownHtmlOutputBytes = options.knownHtmlOutputBytes ?? new Map();
+    const knownHtmlOutputDirectories = knownHtmlIndexDirectories(knownHtmlOutputBytes);
+    for (const bytes of knownHtmlOutputBytes.values()) {
+        sizes.totalOutputBytes += bytes;
+        sizes.publicOutputBytes += bytes;
+        sizes.htmlOutputBytes += bytes;
+        htmlSizes.push(bytes);
+    }
+    await walkFiles(outDir, async (path) => {
+        const publicPath = relative(outDir, path);
+        const parts = publicPath.split(sep);
+        const normalizedPublicPath = parts.join("/");
+        const knownHtmlBytes = options.knownHtmlOutputBytes?.get(normalizedPublicPath);
+        if (knownHtmlBytes !== undefined) {
+            return;
+        }
+        const bytes = (await stat(path)).size;
+        sizes.totalOutputBytes += bytes;
+        if (parts.includes(".stoneage")) {
+            sizes.internalOutputBytes += bytes;
+            return;
+        }
+        sizes.publicOutputBytes += bytes;
+        if (knownHtmlBytes !== undefined || normalizedPublicPath.endsWith(".html")) {
+            sizes.htmlOutputBytes += bytes;
+            htmlSizes.push(bytes);
+        }
+        if (normalizedPublicPath.endsWith(".css")) {
+            sizes.cssOutputBytes += bytes;
+        }
+        if (normalizedPublicPath.endsWith(".js")) {
+            sizes.jsOutputBytes += bytes;
+        }
+        if (isImageOutputPath(normalizedPublicPath)) {
+            sizes.imageOutputBytes += bytes;
+        }
+        if (options.includePublicDataExports && parts[0] === "data") {
+            sizes.dataOutputBytes += bytes;
+        }
+    }, {
+        shouldSkipDirectory: (path) => {
+            if (knownHtmlOutputDirectories.size === 0) {
+                return false;
+            }
+            const publicPath = relative(outDir, path).split(sep).join("/");
+            return knownHtmlOutputDirectories.has(publicPath);
+        },
+    });
+    sizes.averageHtmlBytes = averageBytes(htmlSizes);
+    sizes.p95HtmlBytes = percentileBytes(htmlSizes, 0.95);
+    return sizes;
+}
+function htmlOutputBytesFromManifest(manifest) {
+    return new Map(manifest.pages.map((page) => [page.outputPath, page.htmlBytes]));
+}
+function knownHtmlIndexDirectories(knownHtmlOutputBytes) {
+    const directories = new Set();
+    for (const outputPath of knownHtmlOutputBytes.keys()) {
+        if (!outputPath.endsWith("/index.html")) {
+            continue;
+        }
+        directories.add(outputPath.slice(0, -"/index.html".length));
+    }
+    return directories;
+}
+function largestDependencyFanoutFromManifest(manifest) {
+    const fanout = new Map();
+    for (const output of [...manifest.pages, ...manifest.artifacts]) {
+        for (const key of Object.keys(output.dependencies)) {
+            if (key.startsWith("\0stoneage:")) {
+                continue;
+            }
+            fanout.set(key, (fanout.get(key) ?? 0) + 1);
+        }
+    }
+    return Math.max(0, ...fanout.values());
+}
+function averageBytes(sizes) {
+    if (sizes.length === 0) {
+        return 0;
+    }
+    return sizes.reduce((sum, bytes) => sum + bytes, 0) / sizes.length;
+}
+function percentileBytes(sizes, percentile) {
+    if (sizes.length === 0) {
+        return 0;
+    }
+    const sorted = [...sizes].sort((left, right) => left - right);
+    const index = Math.ceil(sorted.length * percentile) - 1;
+    return sorted[Math.max(0, Math.min(index, sorted.length - 1))] ?? 0;
+}
+function summarizeCompression(metrics) {
+    return {
+        filesCompressed: metrics.filesCompressed,
+        originalBytes: metrics.originalBytes,
+        brotliBytes: metrics.brotliBytes,
+        gzipBytes: metrics.gzipBytes,
+    };
+}
+function createRoutes(data, options = {}) {
+    const conversationsByMember = groupBy(data.conversations, (conversation) => conversation.memberId);
+    const conversationsBySession = groupBy(data.conversations, (conversation) => conversation.sessionId);
+    const membersById = new Map(data.members.map((member) => [member.id, member]));
+    const sessionsById = new Map(data.sessions.map((session) => [session.id, session]));
+    const categoryIndexRows = createCategoryIndexSummaries(data);
+    const yearIndexRows = data.yearlyAggregates;
+    const dataHashing = options.dataHashing ?? { recordsHashed: 0 };
+    const paginationSummary = options.pagination ?? { conversationIndexItemsMaterialized: 0 };
+    const trailingSlash = options.trailingSlash ?? "always";
+    const changedConversation = options.onlyConversationId
+        ? data.conversations.find((conversation) => conversation.id === options.onlyConversationId)
+        : undefined;
+    const lazyHashes = Boolean(changedConversation);
+    const memberHashes = createRecordHashLookup(data.members, (member) => member.id, dataHashing, {
+        lazy: lazyHashes,
+        cacheScope: "member",
+        cache: options.recordHashCache,
+    });
+    const sessionHashes = createRecordHashLookup(data.sessions, (session) => session.id, dataHashing, {
+        lazy: lazyHashes,
+        cacheScope: "session",
+        cache: options.recordHashCache,
+    });
+    const conversationHashes = createRecordHashLookup(data.conversations, (conversation) => conversation.id, dataHashing, {
+        lazy: lazyHashes,
+        cacheScope: "conversation",
+        cache: options.recordHashCache,
+    });
+    const conversationSummaryHashes = createRecordHashLookup(data.conversations, (conversation) => conversation.id, dataHashing, {
+        lazy: lazyHashes,
+        hashFingerprintOf: conversationSummaryFingerprint,
+        cacheScope: "conversation-summary",
+        cache: options.recordHashCache,
+    });
+    const billHashes = createRecordHashLookup(data.bills, (bill) => bill.id, dataHashing, {
+        lazy: lazyHashes,
+        cacheScope: "bill",
+        cache: options.recordHashCache,
+    });
+    const members = changedConversation
+        ? data.members.filter((member) => member.id === changedConversation.memberId)
+        : data.members;
+    const sessions = changedConversation
+        ? data.sessions.filter((session) => session.id === changedConversation.sessionId)
+        : data.sessions;
+    const conversations = changedConversation ? [changedConversation] : data.conversations;
+    const bills = changedConversation ? [] : data.bills;
+    const categoryIndexEntries = changedConversation ? [] : [categoryIndexRows];
+    const yearIndexEntries = changedConversation ? [] : [yearIndexRows];
+    const conversationIndexPages = changedConversation
+        ? [
+            conversationIndexPageForConversation(data.conversations, changedConversation, paginationSummary),
+        ]
+        : paginateConversationIndexPages(data.conversations, paginationSummary, options.conversationIndexCache);
+    return [
+        defineRouteFamily({
+            name: "categoryIndexes",
+            pattern: "/categories/",
+            entries: () => categoryIndexEntries.map((rows) => ({
+                params: {},
+                links: [],
+                dependencies: [{ key: "category-index", hash: hashValue(rows) }],
+                metadata: {
+                    title: "Categories",
+                    description: "Category totals for the generated public-data archive.",
+                },
+                render: () => renderCategoryIndex(rows),
+            })),
+        }),
+        defineRouteFamily({
+            name: "yearIndexes",
+            pattern: "/years/",
+            entries: () => yearIndexEntries.map((rows) => ({
+                params: {},
+                links: [],
+                dependencies: [{ key: "year-index", hash: hashValue(rows) }],
+                metadata: {
+                    title: "Years",
+                    description: "Yearly totals for the generated public-data archive.",
+                },
+                render: () => renderYearIndex(rows),
+            })),
+        }),
+        defineRouteFamily({
+            name: "members",
+            pattern: "/members/:id/:year/",
+            paramMatchers: {
+                year: fourDigitYear,
+            },
+            entries: () => members.map((member) => ({
+                params: { id: member.slug, year: member.year },
+                links: (conversationsByMember.get(member.id) ?? [])
+                    .slice(0, 8)
+                    .map((conversation) => conversationPath(conversation, trailingSlash)),
+                dependencies: [
+                    { key: `member:${member.id}`, hash: requiredHash(memberHashes, member.id) },
+                    ...(conversationsByMember.get(member.id) ?? [])
+                        .slice(0, 8)
+                        .map((conversation) => ({
+                        key: `conversation-summary:${conversation.id}`,
+                        hash: requiredHash(conversationSummaryHashes, conversation.id),
+                    })),
+                ],
+                metadata: {
+                    title: member.name,
+                    description: `${member.name} represents ${member.district} in ${member.year}.`,
+                },
+                render: () => renderMember(member, conversationsByMember.get(member.id) ?? [], options.portraitVariants?.get(member.id) ?? [], trailingSlash),
+            })),
+        }),
+        defineRouteFamily({
+            name: "sessions",
+            pattern: "/sessions/:id/",
+            entries: () => sessions.map((session) => ({
+                params: { id: session.slug },
+                links: (conversationsBySession.get(session.id) ?? [])
+                    .slice(0, sessionConversationPreviewLimit)
+                    .map((conversation) => conversationPath(conversation, trailingSlash)),
+                dependencies: [
+                    { key: `session:${session.id}`, hash: requiredHash(sessionHashes, session.id) },
+                    ...(conversationsBySession.get(session.id) ?? [])
+                        .slice(0, sessionConversationPreviewLimit)
+                        .map((conversation) => ({
+                        key: `conversation-summary:${conversation.id}`,
+                        hash: requiredHash(conversationSummaryHashes, conversation.id),
+                    })),
+                ],
+                metadata: {
+                    title: session.title,
+                    description: `Session held on ${session.date}.`,
+                },
+                render: () => renderSession(session, conversationsBySession.get(session.id) ?? [], trailingSlash),
+            })),
+        }),
+        defineRouteFamily({
+            name: "conversationIndexes",
+            pattern: "/conversations/page/:page/",
+            entries: () => conversationIndexPages.map((page) => ({
+                params: { page: page.page },
+                path: page.page === 1 ? "/conversations/" : undefined,
+                links: conversationIndexLinks(page, trailingSlash),
+                dependencies: page.items.map((conversation) => ({
+                    key: `conversation-index:${conversation.id}`,
+                    hash: requiredHash(conversationSummaryHashes, conversation.id),
+                })),
+                metadata: {
+                    title: page.page === 1 ? "Conversations" : `Conversations page ${page.page}`,
+                    description: `Conversation index page ${page.page} of ${page.totalPages}.`,
+                    prefetch: page.page < page.totalPages
+                        ? [conversationIndexPagePath(page.page + 1, trailingSlash)]
+                        : [],
+                },
+                render: () => renderConversationIndex(page, trailingSlash),
+            })),
+        }),
+        defineRouteFamily({
+            name: "conversations",
+            pattern: "/conversations/:id/",
+            entries: () => conversations.map((conversation) => ({
+                params: { id: conversation.slug },
+                links: [
+                    memberPath(membersById.get(conversation.memberId), trailingSlash),
+                    sessionPath(sessionsById.get(conversation.sessionId), trailingSlash),
+                ],
+                dependencies: [
+                    { key: `conversation:${conversation.id}`, hash: requiredHash(conversationHashes, conversation.id) },
+                ],
+                metadata: {
+                    title: conversation.title,
+                    description: excerpt(conversation.body, 140),
+                },
+                render: () => renderConversation(conversation, membersById.get(conversation.memberId), sessionsById.get(conversation.sessionId), trailingSlash),
+            })),
+        }),
+        defineRouteFamily({
+            name: "bills",
+            pattern: "/bills/:id/",
+            entries: () => bills.map((bill) => ({
+                params: { id: bill.slug },
+                links: [],
+                dependencies: [{ key: `bill:${bill.id}`, hash: requiredHash(billHashes, bill.id) }],
+                metadata: {
+                    title: bill.title,
+                    description: `${bill.title} is currently ${bill.status}.`,
+                },
+                render: () => renderBill(bill),
+            })),
+        }),
+    ];
+}
+function createPublicDataArtifacts(snapshots, trailingSlash) {
+    const artifacts = [
+        snapshots.members,
+        snapshots.sessions,
+        snapshots.conversations,
+        snapshots.bills,
+        snapshots.categories,
+        snapshots.votes,
+        snapshots.yearlyAggregates,
+    ];
+    const data = {
+        members: snapshots.members.data,
+        sessions: snapshots.sessions.data,
+        conversations: snapshots.conversations.data,
+        bills: snapshots.bills.data,
+        categories: snapshots.categories.data,
+        votes: snapshots.votes.data,
+        yearlyAggregates: snapshots.yearlyAggregates.data,
+    };
+    const categoriesById = new Map(data.categories.map((category) => [category.id, category]));
+    const searchDocuments = [
+        ...data.members.map((member) => ({
+            id: member.id,
+            title: member.name,
+            url: memberPath(member, trailingSlash),
+            text: member.district,
+            tags: ["member", member.district, `year:${member.year}`],
+        })),
+        ...data.sessions.map((session) => ({
+            id: session.id,
+            title: session.title,
+            url: sessionPath(session, trailingSlash),
+            text: session.date,
+            tags: ["session"],
+        })),
+        ...data.conversations.map((conversation) => ({
+            id: conversation.id,
+            title: conversation.title,
+            url: conversationPath(conversation, trailingSlash),
+            text: conversation.body,
+            tags: ["conversation"],
+        })),
+        ...data.bills.map((bill) => ({
+            id: bill.id,
+            title: bill.title,
+            url: routeUrl(`/bills/${bill.slug}/`, trailingSlash),
+            text: bill.status,
+            tags: [
+                "bill",
+                bill.status,
+                `category:${categoriesById.get(bill.categoryId)?.slug ?? "uncategorized"}`,
+            ],
+        })),
+    ];
+    return [
+        definePublicDataJsonArtifacts(artifacts, {
+            path: (artifact) => `/data/${artifact.key.replace(/^public:/, "")}.json`,
+        }),
+        defineSearchIndexArtifact({
+            records: searchDocuments,
+            dependencies: artifacts.map((artifact) => artifact.dependency),
+            document: (document) => document,
+        }),
+    ];
+}
+async function writeExampleNormalizedData(outDir, data, dataHashing, recordHashCache) {
+    const normalizedDir = join(outDir, ".stoneage/normalized");
+    const cacheManifestPath = join(outDir, ".stoneage/normalized-manifest.json");
+    const cacheOptions = (scope, records, keyOf, cacheScope) => {
+        if (!recordHashCache) {
+            return {};
+        }
+        const fingerprint = normalizedDataFingerprint(scope, records, keyOf, cacheScope, dataHashing, recordHashCache);
+        return {
+            contentFingerprint: { hash: fingerprint.hash },
+            renderedContent: fingerprint.renderedContent,
+            cacheManifestPath,
+        };
+    };
+    const snapshots = {
+        members: await writeNormalizedJsonData({
+            key: "public:members",
+            path: join(normalizedDir, "members.json"),
+            data: data.members,
+            ...cacheOptions("members", data.members, (member) => member.id, "member"),
+            sourceDependencies: [{ key: "example:members", value: data.members.length }],
+        }),
+        sessions: await writeNormalizedJsonData({
+            key: "public:sessions",
+            path: join(normalizedDir, "sessions.json"),
+            data: data.sessions,
+            ...cacheOptions("sessions", data.sessions, (session) => session.id, "session"),
+            sourceDependencies: [{ key: "example:sessions", value: data.sessions.length }],
+        }),
+        conversations: await writeNormalizedJsonData({
+            key: "public:conversations",
+            path: join(normalizedDir, "conversations.json"),
+            data: data.conversations,
+            ...cacheOptions("conversations", data.conversations, (conversation) => conversation.id, "conversation"),
+            sourceDependencies: [{ key: "example:conversations", value: data.conversations.length }],
+        }),
+        bills: await writeNormalizedJsonData({
+            key: "public:bills",
+            path: join(normalizedDir, "bills.json"),
+            data: data.bills,
+            ...cacheOptions("bills", data.bills, (bill) => bill.id, "bill"),
+            sourceDependencies: [{ key: "example:bills", value: data.bills.length }],
+        }),
+        categories: await writeNormalizedJsonData({
+            key: "public:categories",
+            path: join(normalizedDir, "categories.json"),
+            data: data.categories,
+            ...cacheOptions("categories", data.categories, (category) => category.id, "category"),
+            sourceDependencies: [{ key: "example:categories", value: data.categories.length }],
+        }),
+        votes: await writeNormalizedJsonData({
+            key: "public:votes",
+            path: join(normalizedDir, "votes.json"),
+            data: data.votes,
+            ...cacheOptions("votes", data.votes, (vote) => vote.id, "vote"),
+            sourceDependencies: [{ key: "example:votes", value: data.votes.length }],
+        }),
+        yearlyAggregates: await writeNormalizedJsonData({
+            key: "public:yearly-aggregates",
+            path: join(normalizedDir, "yearly-aggregates.json"),
+            data: data.yearlyAggregates,
+            ...cacheOptions("yearly-aggregates", data.yearlyAggregates, (aggregate) => String(aggregate.year), "yearly-aggregate"),
+            sourceDependencies: [
+                { key: "example:yearly-aggregates", value: data.yearlyAggregates.length },
+            ],
+        }),
+    };
+    const snapshotList = Object.values(snapshots);
+    return {
+        snapshots,
+        summary: {
+            snapshots: snapshotList.length,
+            written: snapshotList.filter((snapshot) => snapshot.written).length,
+            bytes: snapshotList.reduce((sum, snapshot) => sum + snapshot.bytes, 0),
+        },
+    };
+}
+function normalizedDataFingerprint(scope, records, keyOf, cacheScope, dataHashing, recordHashCache) {
+    const recordHashes = createRecordHashLookup(records, keyOf, dataHashing, {
+        lazy: false,
+        cacheScope,
+        cache: recordHashCache,
+    });
+    const hash = createHash("sha256");
+    updateLengthPrefixedHash(hash, scope);
+    for (const record of records) {
+        const key = keyOf(record);
+        updateLengthPrefixedHash(hash, key);
+        updateLengthPrefixedHash(hash, requiredHash(recordHashes, key));
+    }
+    return {
+        hash: compactHashDigest(hash),
+        renderedContent: () => renderNormalizedJsonRecords(records, keyOf, cacheScope, recordHashCache),
+    };
+}
+function renderNormalizedJsonRecords(records, keyOf, cacheScope, recordHashCache) {
+    const serialized = records.map((record) => {
+        const key = keyOf(record);
+        return recordHashCache?.get(`${cacheScope}:${key}`)?.fingerprint ?? JSON.stringify(record);
+    });
+    return `[${serialized.join(",")}]\n`;
+}
+function conversationIndexPageForConversation(conversations, conversation, paginationSummary) {
+    const index = conversations.findIndex((item) => item.id === conversation.id);
+    if (index < 0) {
+        paginationSummary.conversationIndexItemsMaterialized += 0;
+        return paginate([], { pageSize: conversationIndexPageSize })[0];
+    }
+    const page = pageForItemIndex(index, { pageSize: conversationIndexPageSize });
+    const totalPages = Math.ceil(conversations.length / conversationIndexPageSize);
+    const start = (page - 1) * conversationIndexPageSize;
+    const items = conversations.slice(start, start + conversationIndexPageSize);
+    paginationSummary.conversationIndexItemsMaterialized += items.length;
+    return {
+        page,
+        pageSize: conversationIndexPageSize,
+        totalItems: conversations.length,
+        totalPages,
+        items,
+    };
+}
+function paginateConversationIndexPages(conversations, paginationSummary, cache) {
+    const cacheKey = conversationIndexCacheKey(conversations);
+    const cached = cache?.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const pages = paginate(conversations, { pageSize: conversationIndexPageSize });
+    paginationSummary.conversationIndexItemsMaterialized += conversations.length;
+    cache?.set(cacheKey, pages);
+    return pages;
+}
+function conversationIndexCacheKey(conversations) {
+    const first = conversations[0];
+    const last = conversations.at(-1);
+    return [
+        conversationIndexPageSize,
+        conversations.length,
+        first?.id ?? "",
+        first?.slug ?? "",
+        first ? conversationLabel(first) : "",
+        last?.id ?? "",
+        last?.slug ?? "",
+        last ? conversationLabel(last) : "",
+    ].join("|");
+}
+function createRecordHashLookup(items, keyOf, dataHashing, options) {
+    const valueOf = options.hashValueOf ?? ((item) => item);
+    if (!options.lazy) {
+        const hashes = new Map();
+        for (const item of items) {
+            const key = keyOf(item);
+            hashes.set(key, hashRecordItem(options, key, item, valueOf, dataHashing));
+        }
+        return {
+            get: (key) => hashes.get(key),
+        };
+    }
+    const records = new Map(items.map((item) => [keyOf(item), item]));
+    const hashes = new Map();
+    return {
+        get(key) {
+            const current = hashes.get(key);
+            if (current !== undefined) {
+                return current;
+            }
+            const item = records.get(key);
+            if (item === undefined) {
+                return undefined;
+            }
+            const hash = hashRecordItem(options, key, item, valueOf, dataHashing);
+            hashes.set(key, hash);
+            return hash;
+        },
+    };
+}
+function hashRecordItem(options, key, item, valueOf, dataHashing) {
+    return options.hashFingerprintOf
+        ? hashRecordFingerprint(options, key, options.hashFingerprintOf(item), dataHashing)
+        : hashRecordValue(options, key, valueOf(item), dataHashing);
+}
+function hashRecordFingerprint(options, key, fingerprint, dataHashing) {
+    if (options.cache && options.cacheScope) {
+        const cacheKey = `${options.cacheScope}:${key}`;
+        const cached = options.cache.get(cacheKey);
+        if (cached?.fingerprint === fingerprint) {
+            return cached.hash;
+        }
+        const hash = hashFingerprint(fingerprint);
+        options.cache.set(cacheKey, { fingerprint, hash });
+        dataHashing.recordsHashed += 1;
+        return hash;
+    }
+    dataHashing.recordsHashed += 1;
+    return hashFingerprint(fingerprint);
+}
+function hashRecordValue(options, key, value, dataHashing) {
+    if (options.cache && options.cacheScope) {
+        const cacheKey = `${options.cacheScope}:${key}`;
+        const cached = options.cache.get(cacheKey);
+        if (cached && recordHashValueReferences.get(cached) === value) {
+            return cached.hash;
+        }
+        const fingerprint = JSON.stringify(value);
+        if (cached?.fingerprint === fingerprint) {
+            recordHashValueReferences.set(cached, value);
+            return cached.hash;
+        }
+        const hash = hashFingerprint(fingerprint);
+        const entry = { fingerprint, hash };
+        options.cache.set(cacheKey, entry);
+        recordHashValueReferences.set(entry, value);
+        dataHashing.recordsHashed += 1;
+        return hash;
+    }
+    dataHashing.recordsHashed += 1;
+    return hashValue(value);
+}
+function hashFingerprint(fingerprint) {
+    return compactHashDigest(createHash("sha256").update(fingerprint));
+}
+function updateLengthPrefixedHash(hash, value) {
+    hash.update(String(value.length));
+    hash.update(":");
+    hash.update(value);
+    hash.update("\0");
+}
+function compactHashDigest(hash) {
+    return hash.digest().subarray(0, 16).toString("base64url");
+}
+function requiredHash(lookup, key) {
+    const hash = lookup.get(key);
+    if (hash === undefined) {
+        throw new Error(`Missing record hash: ${key}`);
+    }
+    return hash;
+}
+function createExampleData(counts) {
+    const categories = createExampleCategories();
+    const members = Array.from({ length: counts.members }, (_, index) => {
+        const number = index + 1;
+        return {
+            id: `member-${pad(number)}`,
+            slug: `m${number}`,
+            name: `Member ${pad(number)}`,
+            district: `District ${(index % 24) + 1}`,
+            year: 2026,
+        };
+    });
+    const sessions = Array.from({ length: counts.sessions }, (_, index) => {
+        const number = index + 1;
+        return {
+            id: `session-${pad(number)}`,
+            slug: `s${number}`,
+            title: `Session ${pad(number)}`,
+            date: `2026-${pad((index % 12) + 1, 2)}-${pad((index % 27) + 1, 2)}`,
+        };
+    });
+    const conversations = Array.from({ length: counts.conversations }, (_, index) => {
+        const number = index + 1;
+        const member = members[index % members.length];
+        const session = sessions[index % sessions.length];
+        const category = categories[index % categories.length];
+        return {
+            id: `conversation-${pad(number)}`,
+            slug: `c${number}`,
+            memberId: member.id,
+            sessionId: session.id,
+            categoryId: category.id,
+            title: `Conversation ${pad(number)} by ${member.name}`,
+            body: createParagraph(number, member.name, session.title),
+        };
+    });
+    const bills = Array.from({ length: counts.bills }, (_, index) => {
+        const number = index + 1;
+        const category = categories[index % categories.length];
+        return {
+            id: `bill-${pad(number)}`,
+            slug: `b${number}`,
+            categoryId: category.id,
+            title: `Bill ${pad(number)}`,
+            status: ["introduced", "in committee", "passed", "rejected"][index % 4],
+        };
+    });
+    const votes = createExampleVotes(bills, members, sessions, categories);
+    const yearlyAggregates = createYearlyAggregates({
+        members,
+        sessions,
+        conversations,
+        bills,
+        categories,
+        votes,
+    });
+    return {
+        members,
+        sessions,
+        conversations,
+        bills,
+        categories,
+        votes,
+        yearlyAggregates,
+    };
+}
+function createExampleCategories() {
+    return [
+        { id: "category-budget", slug: "budget", name: "Budget" },
+        { id: "category-housing", slug: "housing", name: "Housing" },
+        { id: "category-transportation", slug: "transportation", name: "Transportation" },
+        { id: "category-health", slug: "health", name: "Health" },
+        { id: "category-education", slug: "education", name: "Education" },
+        { id: "category-environment", slug: "environment", name: "Environment" },
+        { id: "category-public-safety", slug: "public-safety", name: "Public Safety" },
+        { id: "category-administration", slug: "administration", name: "Administration" },
+    ];
+}
+function createExampleVotes(bills, members, sessions, categories) {
+    if (members.length === 0 || sessions.length === 0) {
+        return [];
+    }
+    const positions = ["yes", "no", "abstain", "yes"];
+    return bills.map((bill, index) => {
+        const number = index + 1;
+        const session = sessions[index % sessions.length];
+        const member = members[index % members.length];
+        const category = categories.find((item) => item.id === bill.categoryId) ?? categories[0];
+        return {
+            id: `vote-${pad(number)}`,
+            billId: bill.id,
+            memberId: member.id,
+            sessionId: session.id,
+            categoryId: category.id,
+            date: session.date,
+            position: positions[index % positions.length],
+        };
+    });
+}
+function createYearlyAggregates(data) {
+    const years = new Set();
+    for (const member of data.members) {
+        years.add(member.year);
+    }
+    for (const session of data.sessions) {
+        years.add(Number(session.date.slice(0, 4)));
+    }
+    for (const vote of data.votes) {
+        years.add(Number(vote.date.slice(0, 4)));
+    }
+    return [...years]
+        .sort((left, right) => left - right)
+        .map((year) => ({
+        year,
+        memberCount: data.members.filter((member) => member.year === year).length,
+        sessionCount: data.sessions.filter((session) => yearOfDate(session.date) === year).length,
+        conversationCount: data.conversations.filter((conversation) => {
+            const session = data.sessions.find((item) => item.id === conversation.sessionId);
+            return session !== undefined && yearOfDate(session.date) === year;
+        }).length,
+        billCount: data.bills.length,
+        voteCount: data.votes.filter((vote) => yearOfDate(vote.date) === year).length,
+        categoryCount: data.categories.length,
+        passedBillCount: data.bills.filter((bill) => bill.status === "passed").length,
+    }));
+}
+function yearOfDate(date) {
+    return Number(date.slice(0, 4));
+}
+function exampleDataRecordCounts(data) {
+    return {
+        members: data.members.length,
+        sessions: data.sessions.length,
+        conversations: data.conversations.length,
+        bills: data.bills.length,
+        categories: data.categories.length,
+        votes: data.votes.length,
+        yearlyAggregates: data.yearlyAggregates.length,
+    };
+}
+function createCategoryIndexSummaries(data) {
+    return data.categories.map((category) => ({
+        slug: category.slug,
+        name: category.name,
+        conversationCount: data.conversations.filter((conversation) => conversation.categoryId === category.id).length,
+        billCount: data.bills.filter((bill) => bill.categoryId === category.id).length,
+        voteCount: data.votes.filter((vote) => vote.categoryId === category.id).length,
+    }));
+}
+function dataWithMutatedConversation(data, id) {
+    const index = data.conversations.findIndex((conversation) => conversation.id === id);
+    if (index < 0) {
+        return data;
+    }
+    const conversation = data.conversations[index];
+    const conversations = data.conversations.slice();
+    conversations[index] = {
+        ...conversation,
+        title: `${conversation.title} Updated`,
+        body: `${conversation.body} Updated for incremental benchmark.`,
+    };
+    return { ...data, conversations };
+}
+function renderMember(member, conversations, portraitVariants, trailingSlash) {
+    const latest = conversations.slice(0, 8);
+    const portrait = renderMemberPortrait(member, portraitVariants);
+    return `<main class="w">${portrait}<p class="m">${escapeHtml(member.district)}<h1>${escapeHtml(member.name)}</h1><section><h2>Latest conversations</h2><ul>${latest
+        .map((conversation) => `<li><a href="${conversationPath(conversation, trailingSlash)}">${escapeHtml(conversationLabel(conversation))}</a>`)
+        .join("")}</ul></section></main>`;
+}
+function renderMemberPortrait(member, portraitVariants) {
+    const src = `/assets/portraits/${member.id}.png`;
+    const srcset = srcsetFor(portraitVariants.filter((image) => image.format === "webp"));
+    const srcsetAttribute = srcset ? ` srcset="${escapeAttribute(srcset)}" sizes="64px"` : "";
+    return `<img src="${src}"${srcsetAttribute} width="64" height="64" alt="" loading="lazy">`;
+}
+function renderSession(session, conversations, trailingSlash) {
+    return `<main class="w"><p class="m">${escapeHtml(session.date)}<h1>${escapeHtml(session.title)}</h1><p>${conversations.length} conversations are linked to this session.<ul>${conversations
+        .slice(0, sessionConversationPreviewLimit)
+        .map((conversation) => `<li><a href="${conversationPath(conversation, trailingSlash)}">${escapeHtml(conversationLabel(conversation))}</a>`)
+        .join("")}</ul></main>`;
+}
+function renderConversation(conversation, member, session, trailingSlash) {
+    return `<main><h1>${escapeHtml(conversation.title)}</h1><p><a href="${memberPath(member, trailingSlash)}">Member</a><p><a href="${sessionPath(session, trailingSlash)}">Session</a><p>${escapeHtml(conversation.body)}</main>`;
+}
+function conversationIndexLinks(page, trailingSlash) {
+    return [
+        ...page.items.map((conversation) => conversationPath(conversation, trailingSlash)),
+        ...(page.page > 1 ? [conversationIndexPagePath(page.page - 1, trailingSlash)] : []),
+        ...(page.page < page.totalPages ? [conversationIndexPagePath(page.page + 1, trailingSlash)] : []),
+    ];
+}
+function renderConversationIndex(page, trailingSlash) {
+    const previous = page.page > 1
+        ? `<a href="${conversationIndexPagePath(page.page - 1, trailingSlash)}">Previous</a>`
+        : "";
+    const next = page.page < page.totalPages
+        ? `<a href="${conversationIndexPagePath(page.page + 1, trailingSlash)}">Next</a>`
+        : "";
+    return `<main class="w"><p class="m">Page ${page.page} of ${page.totalPages}<h1>Conversations</h1><ul>${page.items
+        .map((conversation) => `<li><a href="${conversationPath(conversation, trailingSlash)}">${escapeHtml(conversationLabel(conversation))}</a>`)
+        .join("")}</ul><nav>${previous}${next}</nav></main>`;
+}
+function renderBill(bill) {
+    return `<main><p class="m">${escapeHtml(bill.status)}<h1>${escapeHtml(bill.title)}</h1><p>This bill page is generated from normalized public data.</main>`;
+}
+function renderCategoryIndex(rows) {
+    return `<main class="w"><h1>Categories</h1><ul>${rows
+        .map((row) => `<li><strong>${escapeHtml(row.name)}</strong> ${row.conversationCount} conversations, ${row.billCount} bills, ${row.voteCount} votes`)
+        .join("")}</ul></main>`;
+}
+function renderYearIndex(rows) {
+    return `<main class="w"><h1>Years</h1><ul>${rows
+        .map((row) => `<li><strong>${row.year}</strong> ${row.conversationCount} conversations, ${row.billCount} bills, ${row.voteCount} votes`)
+        .join("")}</ul></main>`;
+}
+function memberPath(member, trailingSlash) {
+    return routeUrl(`/members/${member.slug}/${member.year}/`, trailingSlash);
+}
+function sessionPath(session, trailingSlash) {
+    return routeUrl(`/sessions/${session.slug}/`, trailingSlash);
+}
+function conversationPath(conversation, trailingSlash) {
+    return routeUrl(`/conversations/${conversation.slug}/`, trailingSlash);
+}
+function conversationIndexPagePath(page, trailingSlash) {
+    return routeUrl(page === 1 ? "/conversations/" : `/conversations/page/${page}/`, trailingSlash);
+}
+function routeUrl(path, trailingSlash) {
+    if (path === "/") {
+        return path;
+    }
+    const withoutTrailingSlash = path.replace(/\/+$/, "");
+    return trailingSlash === "never" ? withoutTrailingSlash : `${withoutTrailingSlash}/`;
+}
+function conversationLabel(conversation) {
+    const [label] = conversation.title.split(" by ", 1);
+    return label ?? conversation.title;
+}
+function conversationSummaryFingerprint(conversation) {
+    return `{"slug":${JSON.stringify(conversation.slug)},"label":${JSON.stringify(conversationLabel(conversation))}}`;
+}
+async function prepareExampleImages(outDir, members, options) {
+    const images = members.map((member) => ({
+        source: join(outDir, `assets/portraits/${member.id}.png`),
+        publicPath: `/assets/portraits/${member.id}.png`,
+        memberId: member.id,
+    }));
+    await Promise.all(images.map((image) => writePlaceholderPng(image.source)));
+    const result = await optimizeImages({
+        outDir,
+        images,
+        widths: [160, 320],
+        formats: ["webp"],
+        skipExisting: true,
+        converter: options.converter,
+        loadConverter: options.loadConverter,
+    });
+    const availableVariants = [
+        ...result.generated,
+        ...result.skipped
+            .filter(existingImageVariantSkipped)
+            .map((image) => ({
+            source: image.source,
+            publicPath: image.publicPath,
+            width: image.width,
+            format: image.format,
+            bytes: image.bytes,
+        })),
+    ];
+    const variantsByMember = new Map();
+    for (const image of images) {
+        variantsByMember.set(image.memberId, availableVariants.filter((variant) => variant.source === image.source));
+    }
+    return {
+        variantsByMember,
+        summary: summarizeImageOptimization(result),
+    };
+}
+function existingImageVariantSkipped(image) {
+    return (image.reason === "existing-current" &&
+        image.publicPath !== undefined &&
+        image.width !== undefined &&
+        image.format !== undefined &&
+        image.bytes !== undefined);
+}
+function summarizeImageOptimization(result) {
+    return {
+        generated: result.generated.length,
+        skipped: result.skipped.length,
+        outputBytes: result.generated.reduce((total, image) => total + image.bytes, 0),
+    };
+}
+function emptyImageOptimization() {
+    return {
+        variantsByMember: new Map(),
+        summary: {
+            generated: 0,
+            skipped: 0,
+            outputBytes: 0,
+        },
+    };
+}
+async function writePlaceholderPng(path) {
+    const content = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=", "base64");
+    await writeBinaryIfChanged(path, content);
+}
+async function writeSiteCss(outDir) {
+    await writeTailwindUtilitiesCss(join(outDir, "s.css"), {
+        candidates: exampleCssCandidates,
+        css: exampleTailwindCss,
+    });
+}
+async function writeJson(path, value) {
+    await writeText(path, `${JSON.stringify(value)}\n`);
+}
+async function writeText(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, value, { flag: "w" });
+}
+async function writeBinaryIfChanged(path, value) {
+    try {
+        const current = await readFile(path);
+        if (current.equals(value)) {
+            return;
+        }
+    }
+    catch (error) {
+        if (!isMissingPath(error)) {
+            throw error;
+        }
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, value, { flag: "w" });
+}
+async function walkFiles(path, onFile, options = {}) {
+    const entries = await readdir(path, { withFileTypes: true });
+    await mapConcurrent(entries, exampleFileWalkConcurrency, async (entry) => {
+        const entryPath = join(path, entry.name);
+        if (entry.isDirectory()) {
+            if (options.shouldSkipDirectory?.(entryPath)) {
+                return;
+            }
+            await walkFiles(entryPath, onFile, options);
+            return;
+        }
+        if (entry.isFile()) {
+            await onFile(entryPath);
+        }
+    });
+}
+async function mapConcurrent(items, concurrency, worker) {
+    const limit = Math.max(1, Math.floor(concurrency));
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            await worker(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => runWorker()));
+}
+function isImageOutputPath(path) {
+    return /\.(avif|gif|jpe?g|png|svg|webp)$/u.test(path);
+}
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function groupBy(items, keyOf) {
+    const map = new Map();
+    for (const item of items) {
+        const key = keyOf(item);
+        const group = map.get(key);
+        if (group) {
+            group.push(item);
+        }
+        else {
+            map.set(key, [item]);
+        }
+    }
+    return map;
+}
+function createParagraph(seed, memberName, sessionTitle) {
+    return `${memberName} discussed budget transparency during ${sessionTitle}. Record ${seed}.`;
+}
+function excerpt(value, length) {
+    return value.length > length ? `${value.slice(0, length - 1)}...` : value;
+}
+function pad(value, length = 3) {
+    return String(value).padStart(length, "0");
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replaceAll('"', "&quot;");
+}