@inflexa-ai/harness 0.46.2 → 0.47.0

package/dist/execution/run-synthesis.js

@@ -7,10 +7,12 @@
  *                            submission is the synthesis.
  *   - `report_blocker`    — the run produced nothing synthesizable. An
  *                            accepted synthesis wins over a blocker.
- *   - `literature_reviewer` — research sub-agent exposed as a tool. The
- *                            runtime registers it one time and gives it here;
- *                            the sub-agent loop's brief is the only context
- *                            handed across the boundary (forSubAgent semantics).
+ *   - the lookups         — the gene, protein, annotation, interaction,
+ *                            PubMed, citation, drug-gene, and preclinical
+ *                            tools (`createSynthesisLookupTools`). Each lookup
+ *                            records the PMIDs of its result, and
+ *                            `submit_synthesis` refuses a PMID that no lookup
+ *                            of the run returned.
  *
  * Two deliverables on a happy path: `synthesis.json` written to the run dir
  * and a `data-run-synthesis` chat data part emitted via the `emit` callback
@@ -27,6 +29,7 @@ import { ok } from "neverthrow";
 import { z } from "zod";
 import { writeFileWithinRoot } from "../lib/fs-helpers.js";
 import { isAllDigits } from "../lib/text.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
 import { tryFs } from "../lib/fs-result.js";
 import { safeParseJsonAs } from "../lib/parse-json.js";
 import { RunSynthesisSchema, SynthesisDraftSchema, } from "../schemas/run-synthesis.js";
@@ -35,8 +38,10 @@ import { composeSystemPrompt } from "../agents/system-prompt.js";
 import { isSafeId, runDir } from "../workspace/paths.js";
 import { runWithSalvage } from "../loop/run-loop.js";
 import { recordedInputOf } from "../loop/tool-adapter.js";
-import { defineTool } from "../tools/define-tool.js";
+import { defineTool, readToolResultImages, withToolCallRecord, withToolResultImages } from "../tools/define-tool.js";
 import { createReadToolOutputTool } from "../tools/read-tool-output.js";
+import { createReadScriptTools } from "../tools/script/file-tools.js";
+import { createReadSurfaceTools } from "../tools/workspace/read-surface.js";
 import { blockerOf, createReportBlockerToolFor, REPORT_BLOCKER_TOOL_ID } from "../tools/sandbox/report-blocker.js";
 // ── Agent identity / budgets ────────────────────────────────────────
 /**
@@ -47,17 +52,75 @@ import { blockerOf, createReportBlockerToolFor, REPORT_BLOCKER_TOOL_ID } from ".
  */
 export const SYNTHESIS_AGENT_ID = "run-synthesizer";
 /**
- * Budget for the synthesizer loop: read summaries + 1–3 reviewer delegations
- * + draft + 1–2 submit/fix cycles + headroom.
+ * Budget for the synthesizer loop: the rounds of lookups, each one a batch of
+ * parallel calls, then the draft, 1–2 submit/fix cycles, and headroom.
  */
-const SYNTHESIZER_MAX_ITERATIONS = 25;
-/**
- * Cap on `literature_reviewer` calls per run. Not named in the prompt: a
- * model treats a stated call-count limit as a target to hit, not a maximum.
- */
-const LITERATURE_REVIEWER_BUDGET = 3;
+const SYNTHESIZER_MAX_ITERATIONS = 40;
 const SubmitSynthesisOutputSchema = z.object({ accepted: z.boolean() });
 const SUBMIT_SYNTHESIS_TOOL_ID = "submit_synthesis";
+// ── The PMIDs of the lookups ────────────────────────────────────────
+/**
+ * The keys under which a lookup gives back its request: `resolve_citation`
+ * returns the citation that it was given, normalized. A PMID there came from
+ * the model, not from a source.
+ */
+const ECHO_KEYS = new Set(["input", "normalized", "supplied", "query"]);
+/** Each PMID that a lookup result holds under a `pmid` or `pmids` key, outside the echo of the request. */
+export function pmidsIn(value, found = new Set()) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            pmidsIn(item, found);
+        return found;
+    }
+    const record = parseUnknownRecord(value);
+    if (record === undefined)
+        return found;
+    for (const [key, child] of Object.entries(record)) {
+        if (ECHO_KEYS.has(key))
+            continue;
+        if (key === "pmid" && (typeof child === "string" || typeof child === "number")) {
+            if (isAllDigits(String(child)))
+                found.add(String(child));
+        }
+        else if (key === "pmids" && Array.isArray(child)) {
+            for (const pmid of child)
+                if (typeof pmid === "string" && isAllDigits(pmid))
+                    found.add(pmid);
+        }
+        else {
+            pmidsIn(child, found);
+        }
+    }
+    return found;
+}
+const PmidRecordSchema = z.object({ pmids: z.array(z.string()) });
+/**
+ * A lookup whose ok result records the PMIDs that it holds. The loop folds the
+ * record into `seen` after each round, on the first run and on each replay, thus
+ * the check of `submit_synthesis` reads the same set in both.
+ */
+export function recordingPmids(tool, seen) {
+    if (tool.foldCallRecord !== undefined)
+        throw new Error(`the lookup ${tool.id} keeps its own call record, which the PMID record would replace`);
+    return {
+        ...tool,
+        execute: async (input, ctx) => (await tool.execute(input, ctx)).map((value) => {
+            const record = parseUnknownRecord(value);
+            if (record === undefined)
+                return value;
+            // The parsed record is a copy without the symbol keys of the value, thus the pictures move over by hand.
+            const images = readToolResultImages(value);
+            const carried = images.length === 0 ? record : withToolResultImages(record, images);
+            return withToolCallRecord(carried, { pmids: [...pmidsIn(record)] });
+        }),
+        foldCallRecord: (record) => {
+            const parsed = PmidRecordSchema.safeParse(record);
+            if (parsed.success)
+                for (const pmid of parsed.data.pmids)
+                    seen.add(pmid);
+        },
+    };
+}
 // ── Validation ──────────────────────────────────────────────────────
 // ── Semantic checks ─────────────────────────────────────────────────
 //
@@ -138,6 +201,20 @@ function checkKeyReferencePmidFormat(keyReferences) {
     }
     return issues;
 }
+function checkPmidsLookedUp(synthesis, lookedUp) {
+    const cited = [
+        ...synthesis.findings.flatMap((f, fi) => f.references.map((r, ri) => ({ pmid: r.pmid, path: `synthesis.findings[${fi}].references[${ri}].pmid` }))),
+        ...synthesis.keyReferences.map((r, i) => ({ pmid: r.pmid, path: `synthesis.keyReferences[${i}].pmid` })),
+    ];
+    return cited
+        .filter(({ pmid }) => pmid.length > 0 && isAllDigits(pmid) && !lookedUp.has(pmid))
+        .map(({ pmid, path }) => ({
+        path,
+        code: "semantic",
+        message: `pmid "${pmid}" is in no lookup result of this run`,
+        hint: "Cite only a PMID that a lookup of this run returned. Look it up, or remove the reference.",
+    }));
+}
 function semanticCheck(synthesis, ctx) {
     return [
         ...checkFindingStepIds(synthesis.findings, ctx),
@@ -145,6 +222,7 @@ function semanticCheck(synthesis, ctx) {
         ...checkKeyReferencesCited(synthesis.keyReferences, synthesis.findings),
         ...checkFindingPmidFormat(synthesis.findings),
         ...checkKeyReferencePmidFormat(synthesis.keyReferences),
+        ...checkPmidsLookedUp(synthesis, ctx.lookedUpPmids),
     ];
 }
 // ── Inner tools ─────────────────────────────────────────────────────
@@ -153,7 +231,7 @@ function buildSubmitTool(ctx) {
         id: SUBMIT_SYNTHESIS_TOOL_ID,
         description: "Submit the synthesis. Checks the payload against the semantic checks " +
             "the arg schema cannot express (stepId refs, theme→finding refs, " +
-            "keyReferences PMIDs cited, numeric PMIDs). On success returns " +
+            "keyReferences PMIDs cited, numeric PMIDs, each PMID returned by a lookup of this run). On success returns " +
             "{accepted: true} — STOP after this. On rejection returns " +
             "{accepted: false, issues} — fix the specific fields at each issue " +
             "path and call again, or switch to report_blocker if the synthesis " +
@@ -196,9 +274,26 @@ function buildBlockerTool() {
  * the checks without driving the whole agent loop.
  */
 export function __buildInnerToolsForTest(args) {
-    const ctx = { knownStepIds: args.knownStepIds };
+    const ctx = { knownStepIds: args.knownStepIds, lookedUpPmids: args.lookedUpPmids ?? new Set() };
     return { submit: buildSubmitTool(ctx), blocker: buildBlockerTool() };
 }
+/** The synthesizer agent of one run. Its submit tool checks the step ids of the summaries and the PMIDs of its lookups. */
+export function synthesizerAgentOf(input) {
+    const knownStepIds = new Set(input.summaries.map((s) => s.stepId));
+    const lookedUpPmids = new Set();
+    const innerCtx = { knownStepIds, lookedUpPmids };
+    const readTools = input.toolOutputStore ? [createReadToolOutputTool(input.toolOutputStore)] : [];
+    // The lookups run in `run_script`, which gives the PMID record of each nested call to its lookup.
+    return {
+        id: SYNTHESIS_AGENT_ID,
+        systemPrompt: composeSystemPrompt(synthesisAgentPrompt),
+        model: input.model,
+        tools: [...createReadSurfaceTools(input.workspace), buildSubmitTool(innerCtx), buildBlockerTool(), ...readTools],
+        scriptTools: [...input.synthesisLookups.map((tool) => recordingPmids(tool, lookedUpPmids)), ...createReadScriptTools(input.workspace)],
+        scriptRuntime: input.scriptRuntime,
+        maxIterations: SYNTHESIZER_MAX_ITERATIONS,
+    };
+}
 /**
  * Drive the synthesizer agent loop to an outcome — the last accepted
  * synthesis (`submit_synthesis`), else a blocker (`report_blocker`).
@@ -208,21 +303,8 @@ export async function generateRunSynthesis(input) {
     if (input.summaries.length === 0) {
         throw new Error("Run synthesis: no step summaries to synthesize");
     }
-    const knownStepIds = new Set(input.summaries.map((s) => s.stepId));
-    const innerCtx = { knownStepIds };
-    const reviewer = input.literatureReviewer;
-    const submitTool = buildSubmitTool(innerCtx);
-    const blockerTool = buildBlockerTool();
-    const readTools = input.toolOutputStore ? [createReadToolOutputTool(input.toolOutputStore)] : [];
-    const tools = [submitTool, blockerTool, reviewer, ...readTools];
-    const agent = {
-        id: SYNTHESIS_AGENT_ID,
-        systemPrompt: composeSystemPrompt(synthesisAgentPrompt),
-        model: input.model,
-        tools,
-        maxIterations: SYNTHESIZER_MAX_ITERATIONS,
-    };
-    const prompt = buildSynthesizerPrompt(input.planNarrative, input.summaries);
+    const agent = synthesizerAgentOf(input);
+    const prompt = synthesizerSeedOf(input.planNarrative, input.summaries);
     const signal = input.signal ?? new AbortController().signal;
     const emit = input.emit ?? (() => { });
     const run = await runWithSalvage(agent, [{ role: "user", content: prompt }], input.session, {
@@ -231,7 +313,6 @@ export async function generateRunSynthesis(input) {
         emit,
         usageRecorder: input.usageRecorder,
         toolOutputStore: input.toolOutputStore,
-        policy: { budget: { [reviewer.id]: LITERATURE_REVIEWER_BUDGET } },
         pause: input.pause,
     }, {
         tools: [SUBMIT_SYNTHESIS_TOOL_ID, REPORT_BLOCKER_TOOL_ID],
@@ -385,7 +466,8 @@ export function formatSynthesisEmbeddingText(synthesis) {
     ].join("\n");
 }
 // ── Prompt builder ──────────────────────────────────────────────────
-function buildSynthesizerPrompt(planNarrative, summaries) {
+/** The first message of the synthesizer: the narrative of the plan and the summary of each step. */
+export function synthesizerSeedOf(planNarrative, summaries) {
     const summaryBlock = summaries.map((s) => `### ${s.stepId} (${s.agentId})\n\n${s.markdown}`).join("\n\n---\n\n");
     return ["## Analytical Narrative", planNarrative, "", "## Step Summaries", summaryBlock].join("\n");
 }

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * the agent with its own seam realizations.
  */
 export { assembleCoreRuntime } from "./runtime/assemble.js";
-export type { CoreRuntime, CoreRuntimeDeps, CoreWorkflowDeps, RegisteredWorkflows, ConversationAssemblyDeps, SandboxStepCallable, MakeReportReferenceResolver, ReportResolverScope, } from "./runtime/assemble.js";
+export type { CoreRuntime, CoreRuntimeDeps, CoreSandboxDeps, CoreWorkflowDeps, RegisteredWorkflows, ConversationAssemblyDeps, SandboxStepCallable, MakeReportReferenceResolver, ReportResolverScope, } from "./runtime/assemble.js";
 export type { ReferenceResolver, ReportSnapshot, ResolvedValue } from "./report-model/reference-resolver.js";
 export type { ResolvePageAsset } from "./tools/report-session/index.js";
 export { PAGE_ASSETS } from "./report-render/assets.js";
@@ -43,7 +43,6 @@ export type { MakeSessionPagePublisher, SessionPageGrant, SessionPageMintFailure
 export type { ResolvePageUrl, SessionPageAccess } from "./tools/report-session/index.js";
 export { bindReadExport, bindSessionEmit } from "./provenance/seam.js";
 export type { ProvenanceExport, ProvenanceSeam, RunProvenanceEvent, SessionProvenanceEvent } from "./provenance/seam.js";
-export type { DerivationSource } from "./state/report-session-state.js";
 export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
 export type { RunLauncher, LaunchOptions } from "./execution/run-launcher.js";
 export { createDbosWorkflowPurger } from "./execution/dbos-workflow-purger.js";
@@ -158,6 +157,7 @@ export type { ResolveWorkspaceRoot } from "./workspace/paths.js";
 export { createSandboxClient } from "./sandbox/create-sandbox.js";
 export type { CreateSandboxClientConfig, SandboxBackendConfig } from "./sandbox/create-sandbox.js";
 export type { SandboxClient } from "./sandbox/client.js";
+export type { AcquireOutcome, BoundLease, LeaseBinding, NoLease, SandboxLeases } from "./sandbox/leases.js";
 export type { ResolveSandboxLabels, SandboxLabels, SandboxSpec } from "./sandbox/types.js";
 export type { SpawnSession } from "./auth/types.js";
 export { describeSandboxError, keepSuspendingRefusal, SandboxFailure } from "./sandbox/sandbox-error.js";
@@ -188,7 +188,6 @@ export type { PlanStep } from "./workflows/execute-analysis-scheduler.js";
 export { planGraphOf } from "./workflows/plan/graph.js";
 export { planPartOf } from "./memory/card-builders.js";
 export { validatePlan } from "./schemas/validate-plan.js";
-export type { ValidatePlanOptions } from "./schemas/validate-plan.js";
 export type { ValidationResult } from "./schemas/validate-plan.js";
 export { upsertPlan, loadPlan, loadPlanRecord } from "./state/plans.js";
 export type { UpsertPlanInput, PlanRecord } from "./state/plans.js";
@@ -206,7 +205,5 @@ export { reportSessionDir } from "./workspace/paths.js";
 export type { LogFields, LogLevel, Logger } from "./lib/logger.js";
 export { defaultErrorFields } from "./lib/logger.js";
 export { createConsoleLogger, createNoopLogger } from "./lib/console-logger.js";
-export { registerSandboxReaper } from "./sandbox/reaper.js";
-export type { RegisterReaperDeps } from "./sandbox/reaper.js";
 export { registerNotificationSweep } from "./sandbox/notification-sweep.js";
 export type { RegisterNotificationSweepDeps } from "./sandbox/notification-sweep.js";

package/dist/index.js

@@ -55,8 +55,7 @@ export { UnavailableSessionPagePublisher } from "./tools/report-session/session-
 // back for the report page. Thus the seam and its vocabulary belong on the front door: an embedder
 // cannot type its realization without them. The two binders ride beside the types, because an
 // embedder that calls `prepareChatTurn` or one tool factory directly binds the same total forms
-// that the assembly binds. `DerivationSource` rides beside the event union, because the derivation
-// event carries the chain of the derived table.
+// that the assembly binds.
 export { bindReadExport, bindSessionEmit } from "./provenance/seam.js";
 // Run launching.
 export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
@@ -314,8 +313,6 @@ export { reportSessionDir } from "./workspace/paths.js";
 // `defaultErrorFields` is the shipped mapping for one with no opinion.
 export { defaultErrorFields } from "./lib/logger.js";
 export { createConsoleLogger, createNoopLogger } from "./lib/console-logger.js";
-// Sandbox-hygiene scheduled workflows. Reaper reclaims a dead host's orphaned
-// containers; the sweep prunes stale notifications. Each is a
-// `@DBOS.scheduled` no-op on an idle system.
-export { registerSandboxReaper } from "./sandbox/reaper.js";
+// The scheduled sweep that prunes stale notifications. It is a `@DBOS.scheduled`
+// no-op on an idle system. The sandbox reconciler registers with the runtime.
 export { registerNotificationSweep } from "./sandbox/notification-sweep.js";

package/dist/input-scan/enrich.d.ts

@@ -17,8 +17,7 @@
  */
 import type { AgentSession } from "../auth/types.js";
 import type { EmitFn } from "../tools/define-tool.js";
-import type { SandboxClient } from "../sandbox/client.js";
-import type { SandboxRef } from "../sandbox/types.js";
+import type { BoundLease } from "../sandbox/leases.js";
 import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
 import type { FileShape, HeaderReadout } from "./types.js";
 /** Members decoded per shape. One is enough to characterise a set whose names already match. */
@@ -45,24 +44,20 @@ export type ReadHeadersArgs = {
     readonly targets: readonly ReadoutTargetSpec[];
     readonly session: AgentSession;
     readonly fs: WorkspaceFilesystem;
-    /** Omit the sandbox to skip container readouts; every other format still reads. */
-    readonly sandboxClient?: SandboxClient;
-    readonly sandbox?: SandboxRef;
+    /** Omit the lease to skip container readouts; every other format still reads. */
+    readonly lease?: BoundLease;
     /** Absolute in-sandbox path of the analysis root (`/{analysisId}`). */
     readonly mountRoot: string;
-    readonly deadlineMs: number;
     readonly emit: EmitFn;
 };
 export type EnrichShapesArgs = {
     readonly shapes: readonly FileShape[];
     readonly session: AgentSession;
     readonly fs: WorkspaceFilesystem;
-    /** Omit the sandbox to skip container readouts; every other format still reads. */
-    readonly sandboxClient?: SandboxClient;
-    readonly sandbox?: SandboxRef;
+    /** Omit the lease to skip container readouts; every other format still reads. */
+    readonly lease?: BoundLease;
     /** Absolute in-sandbox path of the analysis root (`/{analysisId}`). */
     readonly mountRoot: string;
-    readonly deadlineMs: number;
     readonly emit: EmitFn;
 };
 /**

package/dist/input-scan/enrich.js

@@ -65,9 +65,9 @@ export async function readHeaders(args) {
             readouts.set(target.path, await readFromPrefix(args, target));
         }
     }));
-    const { sandboxClient, sandbox } = args;
-    if (containers.length > 0 && sandboxClient && sandbox) {
-        for (const [path, readout] of await decodeContainers(args, { sandboxClient, sandbox }, containers))
+    const { lease } = args;
+    if (containers.length > 0 && lease) {
+        for (const [path, readout] of await decodeContainers(args, lease, containers))
             readouts.set(path, readout);
     }
     return readouts;
@@ -118,7 +118,7 @@ const ReadoutLineSchema = z.object({
     fields: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
     unavailable: z.string().optional(),
 });
-async function decodeContainers(args, machine, containers) {
+async function decodeContainers(args, lease, containers) {
     const readouts = new Map();
     const source = await readFile(CONTAINER_DECODER, "utf8").catch(() => undefined);
     if (source === undefined) {
@@ -129,14 +129,18 @@ async function decodeContainers(args, machine, containers) {
     const byAbsolute = new Map();
     for (const target of containers)
         byAbsolute.set(`${args.mountRoot}/${target.path}`, target);
-    const result = await runSandboxExec({
-        sandboxClient: machine.sandboxClient,
-        sandbox: machine.sandbox,
+    const ran = await runSandboxExec({
+        lease,
         command: ["python3", "-c", source, ...byAbsolute.keys()],
         timeoutSeconds: ENRICH_TIMEOUT_SECONDS,
-        deadlineMs: args.deadlineMs,
         emit: args.emit,
     });
+    if (ran.isErr()) {
+        for (const { path } of containers)
+            readouts.set(path, { path, fields: {}, unavailable: ran.error.error });
+        return readouts;
+    }
+    const result = ran.value;
     for (const line of result.stdout.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed.startsWith("{"))

package/dist/lib/markdown-pdf.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A PDF from markdown, on `marked` and `pdfmake`, with no browser.
+ *
+ * `marked` gives the token tree, and each token maps to a `pdfmake` node: a heading, a paragraph, a list, a GFM table,
+ * a code block, a quote, a rule, and an image. An SVG image, for example a chart of `render_chart`, lands as vector
+ * graphics. The text font is the Roboto that `pdfmake` ships, which holds the Greek letters and the common math signs.
+ *
+ * `pdfmake` resolves a font by a file path, also inside an SVG, thus the fonts land one time in a private temporary
+ * directory. Each URL is refused, and a local path is refused unless it is one of those font files, thus a document
+ * reads nothing that the caller did not give it.
+ */
+/** An image that a document embeds. The caller reads the bytes, thus the document reaches no file and no URL. */
+export type PdfImage = {
+    readonly kind: "svg";
+    readonly svg: string;
+} | {
+    readonly kind: "png" | "jpeg";
+    readonly bytes: Uint8Array;
+};
+/** The source of each image of a markdown text, in the order of the text. */
+export declare function markdownImageSources(markdown: string): string[];
+/** The PDF of a markdown text. `images` holds each image that the text names, by its source. */
+export declare function markdownToPdf(args: {
+    readonly markdown: string;
+    readonly title?: string;
+    readonly images: ReadonlyMap<string, PdfImage>;
+}): Promise<Uint8Array>;

package/dist/lib/markdown-pdf.js

@@ -0,0 +1,236 @@
+/**
+ * A PDF from markdown, on `marked` and `pdfmake`, with no browser.
+ *
+ * `marked` gives the token tree, and each token maps to a `pdfmake` node: a heading, a paragraph, a list, a GFM table,
+ * a code block, a quote, a rule, and an image. An SVG image, for example a chart of `render_chart`, lands as vector
+ * graphics. The text font is the Roboto that `pdfmake` ships, which holds the Greek letters and the common math signs.
+ *
+ * `pdfmake` resolves a font by a file path, also inside an SVG, thus the fonts land one time in a private temporary
+ * directory. Each URL is refused, and a local path is refused unless it is one of those font files, thus a document
+ * reads nothing that the caller did not give it.
+ */
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { lexer } from "marked";
+import { z } from "zod";
+/** The token kinds of the lexer of `marked`. */
+const MARKED_KINDS = new Set([
+    "blockquote",
+    "br",
+    "checkbox",
+    "code",
+    "codespan",
+    "def",
+    "del",
+    "em",
+    "escape",
+    "heading",
+    "hr",
+    "html",
+    "image",
+    "link",
+    "list",
+    "list_item",
+    "paragraph",
+    "space",
+    "strong",
+    "table",
+    "tag",
+    "text",
+]);
+/**
+ * A token of one of the kinds of the lexer. No extension of `marked` is registered, thus a token with one of these
+ * kinds has the shape of that kind.
+ */
+function isMarkedToken(token) {
+    return MARKED_KINDS.has(token.type);
+}
+/** The tokens of the lexer as its own kinds. */
+function tokensOf(tokens) {
+    return (tokens ?? []).filter(isMarkedToken);
+}
+const FontFilesSchema = z.record(z.string(), z.string());
+/** The width of the text block of an A4 page with the margins of {@link documentOf}, in points. */
+const TEXT_WIDTH = 515;
+const FONT_FILES = {
+    normal: "Roboto-Regular.ttf",
+    bold: "Roboto-Medium.ttf",
+    italics: "Roboto-Italic.ttf",
+    bolditalics: "Roboto-MediumItalic.ttf",
+};
+let ready;
+/** The `pdfmake` instance with the fonts on disk and the access policies set. It is set up one time for each process. */
+function pdfmakeOf() {
+    ready ??= (async () => {
+        const { default: pdfmake } = await import("pdfmake");
+        const vfsModule = await import("pdfmake/build/vfs_fonts.js");
+        const vfs = FontFilesSchema.parse(Reflect.get(Object(vfsModule), "default"));
+        const dir = await mkdtemp(join(tmpdir(), "pdf-fonts-"));
+        const paths = {};
+        for (const [style, file] of Object.entries(FONT_FILES)) {
+            const data = vfs[file];
+            if (data === undefined)
+                throw new Error(`pdfmake ships no font file ${file}`);
+            paths[style] = join(dir, file);
+            await writeFile(join(dir, file), Buffer.from(data, "base64"));
+        }
+        const fontPaths = new Set(Object.values(paths));
+        pdfmake.setFonts({ Roboto: paths });
+        pdfmake.setUrlAccessPolicy(() => false);
+        pdfmake.setLocalAccessPolicy((path) => fontPaths.has(path));
+        return pdfmake;
+    })();
+    return ready;
+}
+/** The text runs of inline tokens, with the styles of the marks that hold them. */
+function inline(tokens, images) {
+    const out = [];
+    for (const token of tokensOf(tokens)) {
+        switch (token.type) {
+            case "strong":
+                out.push({ text: inline(token.tokens, images), bold: true });
+                break;
+            case "em":
+                out.push({ text: inline(token.tokens, images), italics: true });
+                break;
+            case "del":
+                out.push({ text: inline(token.tokens, images), decoration: "lineThrough" });
+                break;
+            case "codespan":
+                out.push({ text: token.text, background: "#f2f2f2" });
+                break;
+            case "link":
+                out.push({ text: inline(token.tokens, images), link: token.href, color: "#1a5fb4", decoration: "underline" });
+                break;
+            case "br":
+                out.push({ text: "\n" });
+                break;
+            case "image":
+                out.push({ text: token.text, italics: true });
+                break;
+            case "text":
+                out.push(token.tokens === undefined ? { text: token.text } : { text: inline(token.tokens, images) });
+                break;
+            case "escape":
+                out.push({ text: token.text });
+                break;
+            default:
+                out.push({ text: token.raw });
+        }
+    }
+    return out;
+}
+/** An image of a paragraph that holds one image alone, with its alt text as the caption. */
+function imageNode(token, images) {
+    const image = images.get(token.href);
+    const caption = token.text.length > 0 ? [{ text: token.text, style: "caption" }] : [];
+    if (image === undefined)
+        return [{ text: `[${token.text || token.href}]`, italics: true }];
+    if (image.kind === "svg")
+        return [{ svg: image.svg, width: TEXT_WIDTH, margin: [0, 6, 0, 2] }, ...caption];
+    const data = `data:image/${image.kind};base64,${Buffer.from(image.bytes).toString("base64")}`;
+    return [{ image: data, fit: [TEXT_WIDTH, 600], margin: [0, 6, 0, 2] }, ...caption];
+}
+function blocks(tokens, images) {
+    const out = [];
+    for (const token of tokensOf(tokens)) {
+        switch (token.type) {
+            case "heading":
+                out.push({ text: inline(token.tokens, images), style: `h${String(Math.min(token.depth, 4))}` });
+                break;
+            case "paragraph": {
+                const parts = tokensOf(token.tokens);
+                const only = parts.length === 1 ? parts[0] : undefined;
+                if (only?.type === "image")
+                    out.push(...imageNode(only, images));
+                else
+                    out.push({ text: inline(token.tokens, images), style: "paragraph" });
+                break;
+            }
+            case "list":
+                out.push({
+                    [token.ordered ? "ol" : "ul"]: token.items.map((item) => ({ stack: blocks(item.tokens, images) })),
+                    style: "list",
+                });
+                break;
+            case "table":
+                out.push({
+                    table: {
+                        headerRows: 1,
+                        widths: token.header.map(() => "*"),
+                        body: [
+                            token.header.map((cell) => ({ text: inline(cell.tokens, images), bold: true })),
+                            ...token.rows.map((row) => row.map((cell) => ({ text: inline(cell.tokens, images) }))),
+                        ],
+                    },
+                    layout: "lightHorizontalLines",
+                    style: "table",
+                });
+                break;
+            case "code":
+                out.push({ text: token.text, style: "code", preserveLeadingSpaces: true });
+                break;
+            case "blockquote":
+                out.push({ stack: blocks(token.tokens, images), style: "quote" });
+                break;
+            case "hr":
+                out.push({ canvas: [{ type: "line", x1: 0, y1: 0, x2: TEXT_WIDTH, y2: 0, lineWidth: 0.5, lineColor: "#999999" }], margin: [0, 8, 0, 8] });
+                break;
+            case "text":
+                out.push({ text: inline(token.tokens, images), style: "paragraph" });
+                break;
+            default:
+                // A space, an HTML block, or a link definition prints nothing.
+                break;
+        }
+    }
+    return out;
+}
+/** The source of each image of a markdown text, in the order of the text. */
+export function markdownImageSources(markdown) {
+    const sources = [];
+    const walk = (tokens) => {
+        for (const token of tokensOf(tokens)) {
+            if (token.type === "image")
+                sources.push(token.href);
+            if (token.type === "list")
+                for (const item of token.items)
+                    walk(item.tokens);
+            else if (token.type === "table")
+                for (const cell of [...token.header, ...token.rows.flat()])
+                    walk(cell.tokens);
+            else if ("tokens" in token)
+                walk(token.tokens);
+        }
+    };
+    walk(lexer(markdown));
+    return [...new Set(sources)];
+}
+function documentOf(markdown, title, images) {
+    return {
+        info: title === undefined ? {} : { title },
+        pageSize: "A4",
+        pageMargins: [40, 48, 40, 48],
+        content: [...(title === undefined ? [] : [{ text: title, style: "title" }]), ...blocks(lexer(markdown), images)],
+        defaultStyle: { font: "Roboto", fontSize: 10, lineHeight: 1.25 },
+        styles: {
+            title: { fontSize: 20, bold: true, margin: [0, 0, 0, 12] },
+            h1: { fontSize: 16, bold: true, margin: [0, 12, 0, 6] },
+            h2: { fontSize: 13, bold: true, margin: [0, 10, 0, 4] },
+            h3: { fontSize: 11, bold: true, margin: [0, 8, 0, 4] },
+            h4: { fontSize: 10, bold: true, margin: [0, 6, 0, 2] },
+            paragraph: { margin: [0, 0, 0, 6] },
+            list: { margin: [0, 0, 0, 6] },
+            table: { fontSize: 9, margin: [0, 4, 0, 8] },
+            code: { fontSize: 8.5, background: "#f2f2f2", margin: [0, 2, 0, 8] },
+            quote: { color: "#555555", italics: true, margin: [12, 0, 0, 6] },
+            caption: { fontSize: 8.5, italics: true, color: "#555555", alignment: "center", margin: [0, 0, 0, 8] },
+        },
+    };
+}
+/** The PDF of a markdown text. `images` holds each image that the text names, by its source. */
+export async function markdownToPdf(args) {
+    const pdfmake = await pdfmakeOf();
+    return pdfmake.createPdf(documentOf(args.markdown, args.title, args.images)).getBuffer();
+}