@lchase/kiln 0.1.0 → 0.3.0

package/dist/reconcile.js

@@ -1,3 +1,4 @@
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
 export function inFlightCount(observation) {
     return observation.jobs.filter((job) => inFlight(job, observation)).length;
 }
@@ -14,6 +15,7 @@ function inFlight(job, observation) {
  * `approved` is the approve decision while the run is still alive. It holds
  * a slot and does not unblock dependents. An ok run with no readable
  * decision is `failed`, so a missing artifact cannot unblock the next job.
+ * An investigation is `done` on approve and never `in-review`.
  */
 export function jobState(job, observation) {
     if (job.launchFailed && !job.run)
@@ -60,15 +62,22 @@ export function dependenciesMet(job, observation) {
 export function isLanded(job) {
     return job.run?.status === "ok" && job.run.gateDecision === "approve";
 }
-/** `deliver=local`: landed. `deliver=pr`: landed and the pull request has merged. */
+/**
+ * `deliver=local`: landed. `deliver=pr`: landed and the pull request has merged.
+ * An investigation is done once the gate says approve. There is no pull request.
+ */
 export function isDone(job) {
     if (!isLanded(job))
         return false;
+    if (job.workflow === INVESTIGATION_WORKFLOW)
+        return true;
     if ((job.deliver ?? "local") !== "pr")
         return true;
     return job.delivery?.merged === true || job.delivery?.prState === "MERGED";
 }
 function landedState(job) {
+    if (job.workflow === INVESTIGATION_WORKFLOW)
+        return "done";
     if ((job.deliver ?? "local") !== "pr")
         return "done";
     const delivery = job.delivery;
@@ -85,6 +94,8 @@ function landedState(job) {
 function needsDelivery(job) {
     if (job.error)
         return false;
+    if (job.workflow === INVESTIGATION_WORKFLOW)
+        return false;
     if ((job.deliver ?? "local") !== "pr")
         return false;
     if (!isLanded(job))
@@ -107,6 +118,13 @@ export function decide(observation) {
         type: "clear-breadcrumb",
         path: crumb.path,
     }));
+    for (const job of observation.jobs) {
+        if (job.error || job.workflow !== INVESTIGATION_WORKFLOW)
+            continue;
+        if (!isLanded(job) || job.findingsPath)
+            continue;
+        actions.push({ type: "record-findings", jobId: job.jobId });
+    }
     for (const job of observation.jobs) {
         if (!needsDelivery(job))
             continue;

package/dist/report.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
 import { inFlightCount, isDone, isLanded, jobState, } from "./reconcile.js";
 export function shellQuote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
@@ -28,105 +29,195 @@ export function gateAnswerCommand(checkout, runId, gate, choice, title) {
     const titlePrefix = title ? `KILN_TASK_TITLE=${shellQuote(title)} ` : "";
     return `cd ${shellQuote(checkout)} && mkdir -p ${pendingDir} && printf '%s\\n' ${shellQuote(answer)} > ${answerFile} && ${titlePrefix}${yakInvocation("resume", runId)}`;
 }
-export function renderStatus(observation, jobId) {
-    const jobs = jobId ? observation.jobs.filter((job) => job.jobId === jobId) : observation.jobs;
-    if (jobId && jobs.length === 0) {
+/**
+ * Derived state for every job, or for one id.
+ * Throws `No job <id>` when that id is not on disk, same as `kiln status`.
+ */
+export function statusView(observation, jobId) {
+    const selected = jobId ? observation.jobs.filter((job) => job.jobId === jobId) : observation.jobs;
+    if (jobId && selected.length === 0) {
         throw new Error(`No job ${jobId}.`);
     }
-    if (jobs.length === 0)
+    return { jobs: selected.map((job) => toStatusJob(job, observation)) };
+}
+export function renderStatus(view) {
+    if (view.jobs.length === 0)
         return "no jobs\n";
     const lines = [];
-    for (const job of jobs) {
-        if (job.error) {
-            lines.push(`${job.jobId}  invalid: ${job.error}`);
+    for (const job of view.jobs) {
+        lines.push(statusHeader(job));
+        if (job.state === "invalid")
             continue;
+        for (const detail of statusDetails(job))
+            lines.push(`  ${detail}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Extra lines `kiln status` prints under the job header, without the indent. */
+export function statusDetails(job) {
+    const lines = [];
+    if (job.source)
+        lines.push(`source ${job.source.kind} ${job.source.ref}`);
+    if (job.findingsPath)
+        lines.push(`findings ${job.findingsPath}`);
+    else if (job.workflow === INVESTIGATION_WORKFLOW && job.state === "done")
+        lines.push("findings missing");
+    if (job.prPending)
+        lines.push("pull request not opened yet");
+    if (job.state === "failed" && job.deliveryError)
+        lines.push(job.deliveryError);
+    if (job.state === "failed" && job.prClosedUnmerged && job.prNumber) {
+        lines.push(`pull request #${job.prNumber} was closed without merging`);
+    }
+    if (job.viewError && (job.state === "in-review" || job.state === "done")) {
+        lines.push(`could not read pull request: ${job.viewError}`);
+    }
+    if (job.state === "failed" && job.launchFailed && job.logPath)
+        lines.push(`log ${job.logPath}`);
+    if (job.state === "failed" && job.launchError)
+        lines.push(job.launchError);
+    if (job.noReadableApproval)
+        lines.push("no readable approval decision");
+    if (job.cancelCommand)
+        lines.push(job.cancelCommand);
+    if (job.state === "blocked") {
+        for (const dep of job.dependsOn) {
+            if (dep.blockedDetail)
+                lines.push(dep.blockedDetail);
         }
-        const state = jobState(job, observation);
-        const run = job.run ? `  run ${job.run.runId}` : "";
-        const branch = job.run && (state === "done" || state === "in-review") ? `  branch yak/${job.run.runId}` : "";
-        const pr = prSuffix(job, state);
-        lines.push(`${job.jobId}  ${job.repo}  ${job.workflow}  ${state}${run}${branch}${pr}`);
-        if (job.source)
-            lines.push(`  source ${job.source.kind} ${job.source.ref}`);
-        if (state === "in-review" && !job.delivery?.prNumber) {
-            lines.push("  pull request not opened yet");
-        }
-        if (state === "failed" && job.delivery?.error) {
-            lines.push(`  ${job.delivery.error}`);
-        }
-        if (state === "failed" && job.delivery?.prState === "CLOSED" && job.delivery.prNumber) {
-            lines.push(`  pull request #${job.delivery.prNumber} was closed without merging`);
-        }
-        if (job.delivery?.viewError && (state === "in-review" || state === "done")) {
-            lines.push(`  could not read pull request: ${job.delivery.viewError}`);
-        }
-        if (state === "failed" && job.launchFailed && job.logPath) {
-            lines.push(`  log ${job.logPath}`);
-        }
-        if (state === "failed" && job.launchError) {
-            lines.push(`  ${job.launchError}`);
-        }
-        if (state === "failed" && job.run?.status === "ok" && !job.run.gateDecision) {
-            lines.push("  no readable approval decision");
-        }
-        if (state === "dead" && job.run) {
-            lines.push(`  fix: cd ${shellQuote(job.run.checkout)} && ${yakInvocation("cancel", job.run.runId)}`);
-        }
-        if (state === "blocked") {
-            for (const line of blockedLines(job, observation))
-                lines.push(line);
-        }
-        if (state === "needs-human" && job.run) {
-            for (const gate of job.run.gates) {
-                lines.push(`  gate ${gate.stepId}: ${gate.prompt}`);
-                appendGateCommands(lines, job, gate);
-            }
+    }
+    if (job.state === "needs-human") {
+        for (const gate of job.gates) {
+            lines.push(`gate ${gate.stepId}: ${gate.prompt}`);
+            if (gate.choices.includes("approve"))
+                lines.push(`approve: kiln approve ${job.jobId}`);
+            if (gate.choices.includes("reject"))
+                lines.push(`reject: kiln reject ${job.jobId}`);
         }
     }
-    return `${lines.join("\n")}\n`;
+    return lines;
 }
-function prSuffix(job, state) {
-    const url = job.delivery?.prUrl;
-    if (!url)
-        return "";
-    if (state !== "in-review" && state !== "done" && state !== "failed")
-        return "";
-    return `  pr ${url}`;
+function statusHeader(job) {
+    if (job.state === "invalid")
+        return `${job.jobId}  invalid: ${job.invalidReason ?? "invalid"}`;
+    const run = job.runId ? `  run ${job.runId}` : "";
+    const branch = job.branch ? `  branch ${job.branch}` : "";
+    const pr = job.prUrl && (job.state === "in-review" || job.state === "done" || job.state === "failed")
+        ? `  pr ${job.prUrl}`
+        : "";
+    return `${job.jobId}  ${job.repo}  ${job.workflow}  ${job.state}${run}${branch}${pr}`;
 }
-function blockedLines(job, observation) {
-    const lines = [];
+function toStatusJob(job, observation) {
+    if (job.error) {
+        return {
+            jobId: job.jobId,
+            title: job.title,
+            repo: job.repo,
+            workflow: job.workflow,
+            state: "invalid",
+            dependsOn: dependencyViews(job, observation),
+            stack: job.stack === true,
+            ...(job.source ? { source: { kind: job.source.kind, ref: job.source.ref } } : {}),
+            ...(job.specPath ? { specPath: job.specPath } : {}),
+            ...(job.logPath ? { logPath: job.logPath } : {}),
+            ...(job.findingsPath ? { findingsPath: job.findingsPath } : {}),
+            launchFailed: job.launchFailed,
+            invalidReason: job.error,
+            prPending: false,
+            prClosedUnmerged: false,
+            noReadableApproval: false,
+            gates: [],
+            canApprove: false,
+            canReject: false,
+        };
+    }
+    const state = jobState(job, observation);
+    const gates = state === "needs-human" && job.run ? job.run.gates.map(toGateView) : [];
+    const prNumber = job.delivery?.prNumber;
+    const runId = job.run?.runId;
+    const showBranch = (state === "done" || state === "in-review") && runId !== undefined;
+    return {
+        jobId: job.jobId,
+        title: job.title,
+        repo: job.repo,
+        workflow: job.workflow,
+        state,
+        dependsOn: dependencyViews(job, observation),
+        stack: job.stack === true,
+        ...(job.source ? { source: { kind: job.source.kind, ref: job.source.ref } } : {}),
+        ...(runId ? { runId } : {}),
+        ...(showBranch ? { branch: `yak/${runId}` } : {}),
+        ...(job.delivery?.prUrl ? { prUrl: job.delivery.prUrl } : {}),
+        ...(prNumber ? { prNumber } : {}),
+        ...(job.logPath ? { logPath: job.logPath } : {}),
+        ...(job.specPath ? { specPath: job.specPath } : {}),
+        ...(job.findingsPath ? { findingsPath: job.findingsPath } : {}),
+        launchFailed: job.launchFailed,
+        ...(job.launchError ? { launchError: job.launchError } : {}),
+        ...(job.delivery?.error ? { deliveryError: job.delivery.error } : {}),
+        ...(job.delivery?.viewError ? { viewError: job.delivery.viewError } : {}),
+        prPending: state === "in-review" && !prNumber,
+        prClosedUnmerged: job.delivery?.prState === "CLOSED",
+        noReadableApproval: state === "failed" && job.run?.status === "ok" && !job.run.gateDecision,
+        ...(state === "dead" && job.run
+            ? { cancelCommand: `fix: cd ${shellQuote(job.run.checkout)} && ${yakInvocation("cancel", job.run.runId)}` }
+            : {}),
+        gates,
+        canApprove: gates.some((gate) => gate.choices.includes("approve")),
+        canReject: gates.some((gate) => gate.choices.includes("reject")),
+    };
+}
+function toGateView(gate) {
+    const choices = gate.choices?.length ? gate.choices : ["approve", "reject"];
+    return {
+        stepId: gate.stepId,
+        prompt: gate.prompt,
+        ...(gate.rendered ? { rendered: gate.rendered } : {}),
+        choices,
+        artifacts: gate.artifacts ?? [],
+        reviews: gate.reviews ?? [],
+    };
+}
+function dependencyViews(job, observation) {
+    const reasons = blockReasons(job, observation);
+    return job.dependsOn.map((dep) => {
+        const upstream = observation.jobs.find((candidate) => candidate.jobId === dep);
+        const state = !upstream ? "missing" : upstream.error ? "invalid" : jobState(upstream, observation);
+        const blockedDetail = reasons.find((reason) => reason.dep === dep)?.detail;
+        return {
+            jobId: dep,
+            state,
+            ...(blockedDetail ? { blockedDetail } : {}),
+        };
+    });
+}
+function blockReasons(job, observation) {
+    const reasons = [];
     for (const dep of job.dependsOn) {
         const upstream = observation.jobs.find((candidate) => candidate.jobId === dep);
         if (!upstream) {
-            lines.push(`  blocked on missing job ${dep}`);
+            reasons.push({ dep, detail: `blocked on missing job ${dep}` });
             continue;
         }
         if (job.stack) {
             if (!isLanded(upstream))
-                lines.push(`  waiting for ${dep} to land`);
+                reasons.push({ dep, detail: `waiting for ${dep} to land` });
             continue;
         }
         if (isDone(upstream))
             continue;
         const number = upstream.delivery?.prNumber;
         if (number && !upstream.delivery?.merged && upstream.delivery?.prState !== "CLOSED") {
-            lines.push(`  waiting for PR #${number} to merge`);
+            reasons.push({ dep, detail: `waiting for PR #${number} to merge` });
             continue;
         }
         if ((upstream.deliver ?? "local") === "pr" && isLanded(upstream)) {
-            lines.push(`  waiting for ${dep} to open a pull request`);
+            reasons.push({ dep, detail: `waiting for ${dep} to open a pull request` });
         }
     }
-    return lines;
+    return reasons;
 }
-function appendGateCommands(lines, job, gate) {
-    const choices = gate.choices?.length ? gate.choices : ["approve", "reject"];
-    if (choices.includes("approve"))
-        lines.push(`  approve: kiln approve ${job.jobId}`);
-    if (choices.includes("reject"))
-        lines.push(`  reject: kiln reject ${job.jobId}`);
-}
-export function renderTick(observation, actions, launches, delivers = []) {
+export function renderTick(observation, actions, launches, delivers = [], findings = []) {
     const lines = [`tick  inFlight=${inFlightCount(observation)}  maxConcurrent=${observation.maxConcurrent}`];
     for (const job of observation.jobs) {
         if (job.error)
@@ -141,6 +232,11 @@ export function renderTick(observation, actions, launches, delivers = []) {
             ? `deliver ${deliver.jobId}  ${deliver.repo}  ${deliver.detail}`
             : `deliver ${deliver.jobId}  ${deliver.repo}  failed: ${deliver.detail}`);
     }
+    for (const recorded of findings) {
+        lines.push(recorded.status === "wrote"
+            ? `findings ${recorded.jobId}  ${recorded.path}`
+            : `findings ${recorded.jobId}  missing`);
+    }
     for (const launch of launches) {
         lines.push(`launch ${launch.jobId}  ${launch.repo}`);
         for (const line of launch.output.split("\n")) {
@@ -150,7 +246,8 @@ export function renderTick(observation, actions, launches, delivers = []) {
     }
     if (!actions.some((action) => action.type === "launch") &&
         launches.length === 0 &&
-        delivers.length === 0) {
+        delivers.length === 0 &&
+        findings.length === 0) {
         lines.push("nothing to launch");
     }
     return `${lines.join("\n")}\n`;

package/dist/schemas.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 /**
  * Kiln config file. `repos` is an open map: any name, not a fixed set.
- * `path` is absolute, relative to the config file's directory, or `~`.
+ * `path` is absolute, `~`, or (in older files) relative to the config directory.
+ * `repo add` stores a relative path as absolute, resolved from the working directory.
  * `test` is the shell command a workflow runs as its verify step (`KILN_TEST`).
  */
 /**
@@ -59,6 +60,8 @@ export const JobSchema = z.object({
      * When true, this job starts once its single upstream has landed, on that
      * upstream's branch. Omitted means after-merged: wait until every upstream
      * is `done`. More than one `dependsOn` with `stack` is rejected at add time.
+     * Stacking onto an investigation is rejected: that workflow does not land
+     * a branch.
      */
     stack: z.boolean().optional(),
     source: JobSourceSchema.optional(),
@@ -71,10 +74,12 @@ export const JobSchema = z.object({
  * For `deliver=local`, `done` is a run that finished ok with an approve
  * decision. For `deliver=pr`, `done` is that landed run whose pull request
  * has merged (`state` or `mergedAt`, so a squash merge counts). `in-review`
- * is the landed run while the pull request is still open. A reject, a
- * failure, a dead process, and an ok run with no readable approval do not
- * unblock an after-merged dependent. A stacked job unblocks when its one
- * upstream has landed, which includes `in-review`.
+ * is the landed run while the pull request is still open. An investigation
+ * is `done` when the gate says approve, including when the repo is
+ * `deliver=pr`. It does not enter `in-review`. A reject, a failure, a dead
+ * process, and an ok run with no readable approval do not unblock an
+ * after-merged dependent. A stacked job unblocks when its one upstream has
+ * landed, which includes `in-review`.
  */
 export const JOB_STATES = [
     "queued",

package/dist/serve-page.js

@@ -0,0 +1,216 @@
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
+import { statusDetails } from "./report.js";
+import { JOB_STATES } from "./schemas.js";
+const REFRESH_SECONDS = 3;
+export function renderInbox(css, view) {
+    const waiting = view.jobs.filter((job) => job.state === "needs-human");
+    const body = waiting.length === 0 ? emptyInbox() : waiting.map(renderInboxCard).join("\n");
+    return document({
+        css,
+        title: "Kiln inbox",
+        refresh: true,
+        current: "inbox",
+        main: `<h1>Inbox</h1>
+<p class="lede">Jobs waiting on a person. Approve and reject use the same gate as the CLI.</p>
+${body}`,
+    });
+}
+export function renderBoard(css, view) {
+    const groups = [];
+    const states = [...JOB_STATES, "invalid"];
+    for (const state of states) {
+        const jobs = view.jobs.filter((job) => job.state === state);
+        if (jobs.length === 0)
+            continue;
+        groups.push(`<section class="group" id="state-${escapeHtml(state)}">
+<h2>${escapeHtml(state)} <span class="count">${jobs.length}</span></h2>
+${jobs.map(renderBoardJob).join("\n")}
+</section>`);
+    }
+    const main = groups.length > 0
+        ? groups.join("\n")
+        : `<h1>Board</h1><p class="empty">No jobs.</p>`;
+    const titled = groups.length > 0 ? `<h1>Board</h1>\n${main}` : main;
+    return document({
+        css,
+        title: "Kiln board",
+        refresh: true,
+        current: "board",
+        main: titled,
+    });
+}
+export function renderTextPage(css, title, text) {
+    return document({
+        css,
+        title,
+        refresh: false,
+        current: "inbox",
+        main: `<a class="back" href="/">Inbox</a>
+<h1>${escapeHtml(title)}</h1>
+<pre class="text">${escapeHtml(text)}</pre>`,
+    });
+}
+export function renderMessagePage(css, title, message) {
+    return document({
+        css,
+        title,
+        refresh: false,
+        current: "inbox",
+        main: `<a class="back" href="/">Inbox</a>
+<h1>${escapeHtml(title)}</h1>
+<p class="empty">${escapeHtml(message)}</p>`,
+    });
+}
+function emptyInbox() {
+    return `<p class="empty">Nothing is waiting on a person. The <a href="/board">board</a> lists every job.</p>`;
+}
+function renderInboxCard(job) {
+    const gates = job.gates
+        .map((gate) => {
+        const asking = gate.rendered && gate.rendered !== gate.prompt ? gate.rendered : gate.prompt;
+        const artifacts = gate.artifacts.length === 0
+            ? ""
+            : `<ul class="facts">${gate.artifacts
+                .map((artifact) => `<li><span class="name">${escapeHtml(artifact.name)}</span> ${escapeHtml(artifact.summary)}</li>`)
+                .join("")}</ul>`;
+        const reviews = gate.reviews.length === 0
+            ? ""
+            : `<h4>Reviews</h4><ul class="facts">${gate.reviews
+                .map((review) => `<li><span class="name">${escapeHtml(review.name)}</span> ${escapeHtml(review.summary)}</li>`)
+                .join("")}</ul>`;
+        return `<p class="prompt">${escapeHtml(asking)}</p>${artifacts}${reviews}`;
+    })
+        .join("\n");
+    return `<article class="card" id="job-${escapeHtml(job.jobId)}">
+<h2>${escapeHtml(job.title || job.jobId)}</h2>
+<p class="meta">${escapeHtml(job.repo)} · ${escapeHtml(job.workflow)} · <code>${escapeHtml(job.jobId)}</code>${job.stack ? ' · <span class="chip">stacked</span>' : ""}</p>
+${gates}
+${resourceLinks(job)}
+${actionForms(job)}
+</article>`;
+}
+function renderBoardJob(job) {
+    const deps = job.dependsOn.length === 0
+        ? ""
+        : `<p class="deps">depends on ${job.dependsOn
+            .map((dep) => {
+            const why = dep.blockedDetail ? ` <span class="why">${escapeHtml(dep.blockedDetail)}</span>` : "";
+            return `<a href="/board#job-${encodeURIComponent(dep.jobId)}">${escapeHtml(dep.jobId)}</a> <span class="chip">${escapeHtml(dep.state)}</span>${why}`;
+        })
+            .join(", ")}</p>`;
+    const pr = job.prUrl && (job.state === "in-review" || job.state === "done" || job.state === "failed")
+        ? renderPr(job.prUrl)
+        : "";
+    const details = statusDetails(job);
+    const detailList = details.length === 0
+        ? ""
+        : `<ul class="details">${details
+            .map((line) => `<li class="${detailClass(job.state, line)}">${escapeHtml(line)}</li>`)
+            .join("")}</ul>`;
+    return `<article class="job" id="job-${escapeHtml(job.jobId)}">
+<h3>${escapeHtml(job.title || job.jobId)}</h3>
+<p class="meta">${escapeHtml(job.repo)} · ${escapeHtml(job.workflow)} · <code>${escapeHtml(job.jobId)}</code></p>
+<p class="chips"><span class="chip state-${escapeHtml(job.state)}">${escapeHtml(job.state)}</span>${job.stack ? '<span class="chip">stacked</span>' : ""}</p>
+${deps}
+${pr}
+${detailList}
+${resourceLinks(job)}
+</article>`;
+}
+function detailClass(state, line) {
+    if (line.startsWith("source ") ||
+        line.startsWith("gate ") ||
+        line.startsWith("approve:") ||
+        line.startsWith("reject:") ||
+        line.startsWith("waiting ") ||
+        line.startsWith("blocked on ") ||
+        line.startsWith("fix:")) {
+        return "";
+    }
+    if (state === "failed" || state === "dead")
+        return "bad";
+    return "";
+}
+function renderPr(url) {
+    const safe = httpUrl(url);
+    if (!safe)
+        return `<p class="links">${escapeHtml(url)}</p>`;
+    return `<p class="links"><a href="${escapeHtml(safe)}">Pull request</a></p>`;
+}
+function resourceLinks(job) {
+    const links = [];
+    const id = encodeURIComponent(job.jobId);
+    if (job.specPath)
+        links.push(`<a href="/jobs/${id}/spec">Spec</a>`);
+    if (job.logPath)
+        links.push(`<a href="/jobs/${id}/log">Log</a>`);
+    if (job.workflow === INVESTIGATION_WORKFLOW)
+        links.push(`<a href="/jobs/${id}/findings">Findings</a>`);
+    if (links.length === 0)
+        return "";
+    return `<p class="links">${links.join(" ")}</p>`;
+}
+function actionForms(job) {
+    const forms = [];
+    const id = encodeURIComponent(job.jobId);
+    if (job.canApprove) {
+        forms.push(`<form method="post" action="/api/jobs/${id}/approve"><button class="approve" type="submit">Approve</button></form>`);
+    }
+    if (job.canReject) {
+        forms.push(`<form method="post" action="/api/jobs/${id}/reject"><button class="reject" type="submit">Reject</button></form>`);
+    }
+    if (forms.length === 0)
+        return "";
+    return `<div class="actions">${forms.join("")}</div>`;
+}
+function document(options) {
+    const refresh = options.refresh
+        ? `<meta http-equiv="refresh" content="${REFRESH_SECONDS}">`
+        : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="same-origin">
+${refresh}
+<title>${escapeHtml(options.title)}</title>
+<style>
+${options.css}
+</style>
+</head>
+<body>
+<header class="top">
+  <a class="kiln-mark" href="/">Kiln</a>
+  <nav>
+    <a href="/" ${options.current === "inbox" ? 'aria-current="page"' : ""}>Inbox</a>
+    <a href="/board" ${options.current === "board" ? 'aria-current="page"' : ""}>Board</a>
+  </nav>
+  ${options.refresh ? `<p class="refresh">Refreshes every ${REFRESH_SECONDS}s</p>` : ""}
+</header>
+<main>
+${options.main}
+</main>
+</body>
+</html>
+`;
+}
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function httpUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol === "http:" || url.protocol === "https:")
+            return url.href;
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}