@hraness/slopcamera 3.3.3 → 3.3.5

package/skills/slopcamera/references/educational-video.md

@@ -1,6 +1,6 @@
 # Make an educational film
 
-Use current-source `studio init lesson --template manim-lesson` for Manim visuals, or combine existing diagrams and spatial scenes when they better express the subject. Read [native studio](native-studio.md) for retained jobs and [video projects](video-projects.md) for composition.
+Use `studio init lesson --template manim-lesson` for Manim visuals, or combine existing diagrams and spatial scenes when they better express the subject. Read [native studio](native-studio.md) for retained jobs and [video projects](video-projects.md) for composition.
 
 Preserve supplied mathematical facts, units and labels. Separate an explanatory illustration from a measured simulation or formal proof. Use tested lesson helpers for layout, axes, typography, equations and camera framing; inspect the actual rendered notation and endpoints rather than trusting syntactically valid code.
 

package/skills/slopcamera/references/install.md

@@ -14,7 +14,7 @@ command -v slopcamera
 
 A restricted shell can omit package-manager paths. Check known host installation paths before declaring a tool unavailable. If Bun is genuinely absent, follow its official [installation guide](https://bun.sh/docs/installation) within the user’s authorized setup scope. Do not switch package managers or pipe an unreviewed installer into a shell.
 
-Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.3.2/hraness-slopcamera-3.3.2.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
+Slopcamera installs from its verified release archive: `bun add --global https://github.com/hraness/slopcamera/releases/download/v3.3.4/hraness-slopcamera-3.3.4.tgz`, then `slopcamera doctor --json`. Building from source is the contributor path. Historical Atet archives do not install the renamed CLI; never substitute `slopcamera` into an old archive URL.
 
 Use an existing compatible source build when available. Otherwise follow the [complete source-install guide](https://github.com/hraness/slopcamera/blob/main/docs/how-to/use-current-source.md): clone into a new directory, record its exact commit, install locked dependencies without lifecycle scripts, build the SDK and source CLI, then define the shell command against that checkout. A clone or skill installation alone does not install the executable. Do not alter an existing active checkout to satisfy this path.
 

package/skills/slopcamera/references/patent-drawings.md

@@ -0,0 +1,53 @@
+# Prepare patent-style drawing sheets
+
+Use `diagram sheets` for local monochrome vector drawing sheets with physical
+page dimensions. These commands require current source; do not assume a
+previously published archive includes them. Confirm `slopcamera help diagram`
+lists the commands. If absent, follow [installation](install.md) for an explicit
+source build rather than inventing a flag on ordinary diagram rendering.
+
+## Preserve the authored content
+
+Find the existing `.drawing.json` first. It is the authority for labels,
+reference numerals, geometry, relationships, and sheet order. Never infer an
+invention, assign a component's reference numeral, or expand a claim while
+changing its presentation. Keep private drawings and terminology out of public
+examples and remote services.
+
+The version-one drawing document contains `name`, `paper: "a4" | "us-letter"`,
+an optional metadata-only `title`, and `sheets`. Each sheet has a consecutive
+`figure` number beginning at one and an ordinary version-one `diagram` object.
+There is one figure per sheet.
+
+```sh
+slopcamera diagram sheets init sensor-control.drawing.json --json
+slopcamera diagram sheets check sensor-control.drawing.json --json
+slopcamera diagram sheets render sensor-control.drawing.json --out-dir drawings --json
+```
+
+Run `init` only for new source; it refuses an existing destination. Rendering
+returns artifact paths for the document-name PDF, per-sheet SVGs, and drawing
+receipt. Retain the JSON and receipt. Make revisions in the source and rerender.
+
+## Fit and review the sheets
+
+Coordinates and font sizes use points. The profile does not scale artwork to
+fit. It uses one bundled outlined font, black strokes, a white page, and explicit
+physical bounds. Uppercase ASCII letters and digits must have at least 3.2 mm of
+visible height. Custom fonts, monospace roles, icons, color, and transparency are
+outside this profile. Authored text is limited to 18 pt; sheet and figure numbers
+use 20 pt. Preserve authored meaning when shortening labels or repositioning
+elements.
+
+Inspect every SVG and PDF sheet at full size and two-thirds size. Check labels,
+connectors, reference-numeral consistency with the specification, and reading
+order. Outlined text will not be selectable; inspect pixels and preserve the
+source instead of treating text extraction as a visual check.
+
+The profile follows physical constraints drawn from
+[37 CFR 1.84](https://www.uspto.gov/web/offices/pac/mpep/consolidated_rules.pdf).
+It uses US-style figure numbering, including omission of `FIG.` for a single
+view. [PCT Rule 11](https://www.wipo.int/en/web/pct-system/texts/rules/r11) has its
+own formatting requirements; A4 paper alone does not establish PCT compliance.
+Report checked geometry and provenance separately from technical disclosure or
+filing approval. A receipt does not establish patentability or legal compliance.

package/skills/slopcamera/references/workflows-sdk.md

@@ -15,7 +15,7 @@ For custom local authoring, use `slopcamera code init workflow.ts`, inspect the
 
 Discover exact local inputs with `slopcamera operations list|show`. No host accepts arbitrary new operation registration or caller-selected shell/argv. The fixed `slopcamera.studio.run` is an explicit exception for previously retained native source: its bundle/job input remains typed, while executable paths and trusted-current-user authority belong to the host invocation. The checked `examples/studio/native-workflow.ts` uses `defineWorkflow` and `StudioRunInputSchema` from the local entrypoint.
 
-`media.ingest` needs an existing ordinary project. There is no public generic arbitrary-file SDK project-create operation. Follow [video projects](video-projects.md) for the supported recording, native, and directing entry paths, or [music videos](music-video.md) for the current-source `html render` CLI that creates a project from an authored scene and optional soundtrack. Never synthesize their receipts or depend on private constructors.
+`media.ingest` needs an existing ordinary project. There is no public generic arbitrary-file SDK project-create operation. Follow [video projects](video-projects.md) for the supported recording, native, and directing entry paths, or [music videos](music-video.md) for the `html render` CLI that creates a project from an authored scene and optional soundtrack. Never synthesize their receipts or depend on private constructors.
 
 ## Inspect, approve and resume exact work
 

package/src/cli.ts

@@ -36,6 +36,7 @@ import {
 import type { HostResourceCoordinator } from "./host-resources.js"
 import { installSkill, type SkillScope, type SkillTarget } from "./skill-install.js"
 import { pathExists } from "./fs.js"
+import { checkDrawingFile, renderDrawingFile, starterDrawingSource } from "./drawing.js"
 import { SLOPCAMERA_VERSION } from "./version.js"
 import { reportUsefulResult, type UsefulResultObserver } from "./support-completion.js"
 import { runProductSupportCommand, showProductSupportInvitation, standaloneSupportEnvironment } from "./support.js"
@@ -50,6 +51,9 @@ Usage:
   slopcamera diagram init [file]
   slopcamera diagram check <file> [--config <file>] [--strict]
   slopcamera diagram render <file> [--out-dir <directory>] [--config <file>] [--scale <number>]
+  slopcamera diagram sheets init <file.drawing.json> [--json]
+  slopcamera diagram sheets check <file.drawing.json> [--json]
+  slopcamera diagram sheets render <file.drawing.json> [--out-dir <directory>] [--json]
   slopcamera image vectorize <image> --output <file.svg> [--json] [--duotone <#rgb,#rgb>]
   slopcamera image generate <prompt> --output <file.png|jpg|webp> [--model <provider/model>] [--json]
   slopcamera image icon <subject> --output <file.svg> [--purpose <mark|illustration>]
@@ -66,7 +70,7 @@ Usage:
   slopcamera skill path
   slopcamera skill install [--target codex|claude|agents] [--scope user|project] [--force]
 
-Render writes the same five replaceable artifacts on every run:
+Diagram render writes the same five replaceable artifacts on every run:
   <name>.tldr
   <name>.light.svg
   <name>.dark.svg
@@ -76,6 +80,11 @@ Render writes the same five replaceable artifacts on every run:
   The .tldr file is editable interchange for browser-based canvas tooling.
   Rendering does not require a desktop application or a bundled UI runtime.
 
+Diagram sheets creates bounded black-and-white drawing sheets from a separate
+.drawing.json source: one vector PDF, one outlined SVG per sheet, and a receipt.
+Check is read-only; init never overwrites. Geometry checks do not certify legal
+compliance. This surface is available through the CLI and root SDK.
+
 Vectorize adaptively traces a raster with a checksum-pinned VTracer binary.
 It enforces bounded input, decode, time, path, and output budgets and emits a
 safe path-only SVG (plus an internal vector alpha mask when fidelity requires).
@@ -251,13 +260,88 @@ function hostAdmissionOptions(
     : { hostResourceCoordinator: dependencies.hostResourceCoordinator }
 }
 
+async function runDrawingSheets(
+  args: readonly string[],
+  dependencies: SlopcameraCliDependencies,
+): Promise<void> {
+  const [command, ...rest] = args
+  if (command !== "init" && command !== "check" && command !== "render") {
+    throw new Error("Use slopcamera diagram sheets init, check, or render <file.drawing.json>")
+  }
+  const positionals: string[] = []
+  const seen = new Set<string>()
+  let outDirectory: string | undefined
+  let json = false
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index]!
+    if (!argument.startsWith("-")) {
+      positionals.push(argument)
+      continue
+    }
+    if (argument !== "--json" && !(command === "render" && argument === "--out-dir")) {
+      throw new Error(`Unknown diagram sheets ${command} option: ${argument}`)
+    }
+    if (seen.has(argument)) throw new Error(`${argument} may be supplied at most once`)
+    seen.add(argument)
+    if (argument === "--json") {
+      json = true
+    } else {
+      const value = rest[index + 1]
+      if (value === undefined || value.startsWith("-") || value.trim().length === 0) {
+        throw new Error("--out-dir requires a directory")
+      }
+      outDirectory = value
+      index += 1
+    }
+  }
+  if (positionals.length !== 1 || positionals[0]!.trim().length === 0) {
+    throw new Error(`slopcamera diagram sheets ${command} requires exactly one drawing file`)
+  }
+  const filePath = resolve(positionals[0]!)
+  if (!filePath.endsWith(".drawing.json")) throw new Error("Drawing source must end in .drawing.json")
+  const log = dependencies.log ?? console.log
+  if (command === "init") {
+    try {
+      await writeFile(filePath, `${JSON.stringify(starterDrawingSource(), null, 2)}\n`, { flag: "wx" })
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+        throw new Error(`Refusing to overwrite existing file: ${filePath}`)
+      }
+      throw error
+    }
+    log(json ? JSON.stringify({ command: "diagram.sheets.init", source: filePath }) : `Created ${filePath}`)
+    reportUsefulResult(dependencies.onUsefulResult)
+    return
+  }
+  if (command === "check") {
+    const checks = await withSlopcameraOperationHostAdmission(
+      "slopcamera.diagram.check",
+      async () => await checkDrawingFile({ filePath }),
+      hostAdmissionOptions(dependencies),
+    )
+    log(json
+      ? JSON.stringify({ command: "diagram.sheets.check", source: filePath, ...checks })
+      : `Valid drawing: ${checks.sheetCount} sheet${checks.sheetCount === 1 ? "" : "s"} (${checks.paper}, ${checks.profile}).`)
+    return
+  }
+  const result = await withSlopcameraOperationHostAdmission(
+    "slopcamera.diagram.render",
+    async () => await renderDrawingFile({ filePath, ...(outDirectory === undefined ? {} : { outDirectory }) }),
+    hostAdmissionOptions(dependencies),
+  )
+  log(json
+    ? JSON.stringify({ command: "diagram.sheets.render", artifacts: result.artifacts, checks: result.checks })
+    : [result.artifacts.pdf, ...result.artifacts.sheets, result.artifacts.receipt].join("\n"))
+  reportUsefulResult(dependencies.onUsefulResult)
+}
+
 function canonicalArguments(args: readonly string[]): readonly string[] {
   const [surface, subcommand, ...rest] = args
   if (surface === "diagram") {
     if (subcommand === "init" || subcommand === "check" || subcommand === "render") {
       return [subcommand, ...rest]
     }
-    throw new Error("Use slopcamera diagram init, check, or render")
+    throw new Error("Use slopcamera diagram init, check, render, or sheets")
   }
   if (surface === "image") {
     if (
@@ -286,6 +370,10 @@ export async function main(
   args: readonly string[],
   dependencies: SlopcameraCliDependencies = {},
 ): Promise<void> {
+  if (args[0] === "diagram" && args[1] === "sheets") {
+    await runDrawingSheets(args.slice(2), dependencies)
+    return
+  }
   if (args[0] === "support") {
     process.exitCode = await runProductSupportCommand(args.slice(1),
       dependencies.supportEnvironment === undefined ? {} : { env: dependencies.supportEnvironment })

package/src/drawing-pdf.ts

@@ -0,0 +1,210 @@
+/** A closed adapter for the path-only SVG produced by the pinned resvg renderer. */
+interface SvgNode { readonly tag: string; readonly attrs: Readonly<Record<string, string>>; readonly children: SvgNode[] }
+
+function fail(message: string): never { throw new Error(`Unsupported drawing SVG: ${message}`) }
+const maximumSvgBytes = 2 * 1024 * 1024
+
+function attributes(value: string): Record<string, string> {
+  const attrs: Record<string, string> = {}
+  let rest = value
+  while (rest.trim().length > 0) {
+    const match = /^\s+([A-Za-z][A-Za-z0-9:-]*)="([^"<>]*)"/u.exec(rest)
+    if (match === null) fail("malformed attribute")
+    const name = match[1]!
+    if (Object.hasOwn(attrs, name)) fail("duplicate attribute")
+    attrs[name] = match[2]!
+    rest = rest.slice(match[0].length)
+  }
+  return attrs
+}
+
+function parseSvg(svg: string): SvgNode {
+  if (Buffer.byteLength(svg) > maximumSvgBytes) fail("sheet exceeds byte limit")
+  const roots: SvgNode[] = []
+  const stack: SvgNode[] = []
+  let cursor = 0
+  let count = 0
+  for (const token of svg.matchAll(/<[^>]*>/gu)) {
+    if (svg.slice(cursor, token.index).trim() !== "") fail("text outside a path")
+    cursor = token.index + token[0].length
+    const raw = token[0]
+    const closing = /^<\/([A-Za-z]+)>$/u.exec(raw)
+    if (closing !== null) {
+      if (stack.pop()?.tag !== closing[1]) fail("unbalanced tags")
+      continue
+    }
+    const match = /^<([A-Za-z]+)([\s\S]*?)(\/?)>$/u.exec(raw)
+    if (match === null) fail("unsupported markup")
+    const tag = match[1]!
+    if (!["svg", "defs", "clipPath", "g", "path"].includes(tag)) fail(`element ${tag}`)
+    if (++count > 50_000 || stack.length > 32) fail("tree limit exceeded")
+    const node: SvgNode = { tag, attrs: attributes(match[2]!), children: [] }
+    const parent = stack.at(-1)
+    if (parent === undefined) roots.push(node)
+    else parent.children.push(node)
+    if (match[3] !== "/") stack.push(node)
+  }
+  if (svg.slice(cursor).trim() !== "" || stack.length !== 0 || roots.length !== 1 || roots[0]?.tag !== "svg") fail("invalid document")
+  return roots[0]!
+}
+
+function only(node: SvgNode, allowed: readonly string[]): void {
+  for (const key of Object.keys(node.attrs)) if (!allowed.includes(key)) fail(`${node.tag}.${key}`)
+}
+
+function number(value: string): number {
+  if (!/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/u.test(value)) fail("invalid number")
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || Math.abs(parsed) > 10_000_000) fail("number outside bounds")
+  return parsed
+}
+
+const decimal = (value: number): string => Number(value.toFixed(6)).toString()
+
+function pathCommands(data: string): string {
+  const tokens = data.match(/[MLCQZ]|[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/gu) ?? []
+  if (data.replace(/[MLCQZ]|[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?|[\s,]/gu, "") !== "") fail("path command")
+  if (tokens.length > 500_000) fail("path limit")
+  const result: string[] = []
+  let cursor = 0
+  let x = 0
+  let y = 0
+  let startX = 0
+  let startY = 0
+  const take = (): number => {
+    const token = tokens[cursor++]
+    if (token === undefined) fail("truncated path")
+    return number(token)
+  }
+  while (cursor < tokens.length) {
+    const command = tokens[cursor++]!
+    if (command === "M" || command === "L") {
+      x = take(); y = take()
+      if (command === "M") { startX = x; startY = y }
+      result.push(`${decimal(x)} ${decimal(y)} ${command === "M" ? "m" : "l"}`)
+    } else if (command === "C") {
+      const values = [take(), take(), take(), take(), take(), take()]
+      x = values[4]!; y = values[5]!
+      result.push(`${values.map(decimal).join(" ")} c`)
+    } else if (command === "Q") {
+      const qx = take(); const qy = take(); const nextX = take(); const nextY = take()
+      result.push(`${[x + 2 * (qx - x) / 3, y + 2 * (qy - y) / 3, nextX + 2 * (qx - nextX) / 3, nextY + 2 * (qy - nextY) / 3, nextX, nextY].map(decimal).join(" ")} c`)
+      x = nextX; y = nextY
+    } else if (command === "Z") {
+      result.push("h"); x = startX; y = startY
+    } else fail("non-absolute path command")
+  }
+  return result.join("\n")
+}
+
+function color(value: string | undefined): "0" | "1" | undefined {
+  if (value === "none") return undefined
+  if (value === undefined || value === "#000000") return "0"
+  if (value === "#ffffff") return "1"
+  return fail("non-monochrome paint")
+}
+
+function svgStream(svg: string, width: number, height: number): string {
+  const root = parseSvg(svg)
+  only(root, ["width", "height", "viewBox", "xmlns"])
+  if (number((root.attrs.width ?? "").replace(/pt$/u, "")) !== width || number((root.attrs.height ?? "").replace(/pt$/u, "")) !== height || root.attrs.viewBox !== `0 0 ${width} ${height}` || root.attrs.xmlns !== "http://www.w3.org/2000/svg") fail("page geometry")
+  const clips = new Map<string, SvgNode>()
+  for (const defs of root.children.filter(node => node.tag === "defs")) {
+    only(defs, [])
+    for (const clip of defs.children) {
+      only(clip, ["id"])
+      if (clip.tag !== "clipPath" || clip.attrs.id === undefined || clips.has(clip.attrs.id) || clip.children.some(child => child.tag !== "path")) fail("clip definition")
+      clips.set(clip.attrs.id, clip)
+    }
+  }
+  const output: string[] = [`q\n1 0 0 -1 0 ${decimal(height)} cm`]
+  const emit = (node: SvgNode): void => {
+    if (node.tag === "defs") return
+    if (node.tag === "g") {
+      only(node, ["transform", "clip-path"])
+      output.push("q")
+      if (node.attrs.transform !== undefined) {
+        const match = /^matrix\(([^)]+)\)$/u.exec(node.attrs.transform)
+        if (match === null) fail("transform")
+        const values = match[1]!.trim().split(/[\s,]+/u).map(number)
+        if (values.length !== 6) fail("matrix")
+        output.push(`${values.map(decimal).join(" ")} cm`)
+      }
+      if (node.attrs["clip-path"] !== undefined) {
+        const id = /^url\(#([A-Za-z0-9_-]+)\)$/u.exec(node.attrs["clip-path"])?.[1]
+        const clip = id === undefined ? undefined : clips.get(id)
+        if (clip === undefined) fail("missing clip")
+        for (const path of clip.children) {
+          only(path, ["d", "fill", "stroke", "fill-rule", "clip-rule"])
+          if (path.children.length > 0) fail("path children")
+          output.push(pathCommands(path.attrs.d ?? ""))
+        }
+        const rules = new Set(clip.children.map(path => path.attrs["clip-rule"] ?? path.attrs["fill-rule"] ?? "nonzero"))
+        if (rules.size !== 1 || !["nonzero", "evenodd"].includes([...rules][0]!)) fail("clip rule")
+        output.push(rules.has("evenodd") ? "W* n" : "W n")
+      }
+      node.children.forEach(emit)
+      output.push("Q")
+      return
+    }
+    if (node.tag !== "path") fail("nested non-path element")
+    only(node, ["d", "fill", "stroke", "stroke-width", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "fill-rule", "paint-order"])
+    if (node.children.length > 0) fail("path children")
+    const fill = color(node.attrs.fill)
+    const stroke = color(node.attrs.stroke ?? "none")
+    const cap = ["butt", "round", "square"].indexOf(node.attrs["stroke-linecap"] ?? "butt")
+    const join = ["miter", "round", "bevel"].indexOf(node.attrs["stroke-linejoin"] ?? "miter")
+    const strokeWidth = number(node.attrs["stroke-width"] ?? "1")
+    const miter = number(node.attrs["stroke-miterlimit"] ?? "4")
+    if (cap < 0 || join < 0 || strokeWidth <= 0 || miter < 1) fail("stroke style")
+    const rule = node.attrs["fill-rule"] ?? "nonzero"
+    if (rule !== "nonzero" && rule !== "evenodd") fail("fill rule")
+    const paintOrder = node.attrs["paint-order"] ?? "normal"
+    if (!["normal", "stroke", "stroke fill", "fill stroke", "stroke fill markers", "fill stroke markers"].includes(paintOrder)) fail("paint order")
+    output.push("q", `${strokeWidth} w`, `${cap} J`, `${join} j`, `${miter} M`)
+    if (fill !== undefined) output.push(`${fill} g`)
+    if (stroke !== undefined) output.push(`${stroke} G`)
+    const path = pathCommands(node.attrs.d ?? "")
+    const fillOperator = rule === "evenodd" ? "f*" : "f"
+    if (paintOrder.startsWith("stroke") && stroke !== undefined && fill !== undefined) output.push(path, "S", path, fillOperator)
+    else output.push(path, fill === undefined ? (stroke === undefined ? "n" : "S") : stroke === undefined ? fillOperator : rule === "evenodd" ? "B*" : "B")
+    output.push("Q")
+  }
+  root.children.forEach(emit)
+  output.push("Q")
+  return output.join("\n")
+}
+
+const pdfString = (value: string): string => `<FEFF${Buffer.from(value, "utf16le").swap16().toString("hex")}>`
+
+export function drawingSheetsPdf(
+  sheets: readonly { readonly svg: string; readonly width: number; readonly height: number }[],
+  metadata: { readonly title: string; readonly sourceSha256: string; readonly rendererVersion: string },
+): Uint8Array {
+  if (sheets.length < 1 || sheets.length > 20 || !/^[a-f0-9]{64}$/u.test(metadata.sourceSha256)) throw new Error("Invalid drawing PDF input")
+  const objects: string[] = ["", ""]
+  const pages: number[] = []
+  for (const sheet of sheets) {
+    const stream = svgStream(sheet.svg, sheet.width, sheet.height)
+    const streamId = objects.push(`<< /Length ${Buffer.byteLength(stream)} >>\nstream\n${stream}\nendstream`)
+    pages.push(objects.push(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${decimal(sheet.width)} ${decimal(sheet.height)}] /Resources << >> /Contents ${streamId} 0 R >>`))
+  }
+  objects[0] = "<< /Type /Catalog /Pages 2 0 R >>"
+  objects[1] = `<< /Type /Pages /Count ${pages.length} /Kids [${pages.map(id => `${id} 0 R`).join(" ")}] >>`
+  const infoId = objects.push(`<< /Title ${pdfString(metadata.title)} /Producer ${pdfString(`Slopcamera ${metadata.rendererVersion}`)} /Subject ${pdfString(`source-sha256:${metadata.sourceSha256}; profile:patent-line-art-v1`)} >>`)
+  const chunks: string[] = ["%PDF-1.7\n%Slopcamera vector drawings\n"]
+  const offsets = [0]
+  let offset = Buffer.byteLength(chunks[0]!)
+  for (const [index, object] of objects.entries()) {
+    offsets.push(offset)
+    const chunk = `${index + 1} 0 obj\n${object}\nendobj\n`
+    chunks.push(chunk); offset += Buffer.byteLength(chunk)
+  }
+  // Each cross-reference entry is exactly 20 bytes, including its line ending.
+  const freeEntry = "0000000000 65535 f".padEnd(19, " ") + "\n"
+  const usedEntries = offsets.slice(1).map(value => `${String(value).padStart(10, "0")} 00000 n`.padEnd(19, " ") + "\n").join("")
+  chunks.push(`xref\n0 ${objects.length + 1}\n${freeEntry}${usedEntries}trailer\n<< /Size ${objects.length + 1} /Root 1 0 R /Info ${infoId} 0 R >>\nstartxref\n${offset}\n%%EOF\n`)
+  const bytes = Buffer.from(chunks.join(""))
+  if (bytes.length > 32 * 1024 * 1024) throw new Error("Drawing PDF exceeds output byte limit")
+  return bytes
+}