@gongbaodd/qr-renderer 0.1.0

package/dist/node.js

@@ -0,0 +1,3130 @@
+// src/core/imaging/node.ts
+import { createHash } from "node:crypto";
+import sharp from "sharp";
+
+// src/core/errors.ts
+var QrPosterError = class extends Error {
+  code;
+  exitCode;
+  constructor(code, message, exitCode = 2, options) {
+    super(message, options);
+    this.name = "QrPosterError";
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+};
+
+// src/core/imaging/node.ts
+var nodeImaging = {
+  async decodePng(file) {
+    try {
+      const bytes = Buffer.from(file.buffer, file.byteOffset, file.byteLength);
+      const source = sharp(bytes, { failOn: "error", limitInputPixels: 16e6 });
+      const metadata = await source.metadata();
+      if (metadata.format !== "png" || !metadata.width || !metadata.height) throw new Error("not a decodable PNG");
+      const { data, info } = await source.ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+      return {
+        data,
+        width: info.width,
+        height: info.height
+      };
+    } catch (error) {
+      throw new QrPosterError("INVALID_INPUT", "Could not decode the image as PNG.", 2, { cause: error });
+    }
+  },
+  async encodePngRgba(data, width, height) {
+    const png = await sharp(Buffer.from(data.buffer, data.byteOffset, data.byteLength), {
+      raw: { width, height, channels: 4 }
+    }).png().toBuffer();
+    return png;
+  },
+  async encodePngGrayscale(data, width, height) {
+    const png = await sharp(Buffer.from(data.buffer, data.byteOffset, data.byteLength), {
+      raw: { width, height, channels: 1 }
+    }).png().toBuffer();
+    return png;
+  },
+  async rasterizeSvg(svg, width, height) {
+    const { data, info } = await sharp(Buffer.from(svg)).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    if (info.width !== width || info.height !== height) {
+      throw new QrPosterError(
+        "IMAGE_PROCESSING_FAILED",
+        `SVG rasterization produced ${info.width}x${info.height} instead of ${width}x${height}.`,
+        3
+      );
+    }
+    return { data, width: info.width, height: info.height };
+  },
+  async renderSvgToPng(svg, options) {
+    const raster = sharp(Buffer.from(svg));
+    const { data, info } = await (options.flatten ? raster.flatten({ background: "#ffffff" }) : raster).png().toBuffer({ resolveWithObject: true });
+    return {
+      png: data,
+      width: info.width,
+      height: info.height
+    };
+  },
+  async composeQrPng(basePng, overlaySvgs) {
+    const composites = overlaySvgs.filter((svg) => svg.length > 0).map((svg) => ({ input: Buffer.from(svg) }));
+    const png = composites.length === 0 ? await sharp(Buffer.from(basePng.buffer, basePng.byteOffset, basePng.byteLength)).png().toBuffer() : await sharp(Buffer.from(basePng.buffer, basePng.byteOffset, basePng.byteLength)).composite(composites).png().toBuffer();
+    return png;
+  },
+  async normalizeQrPng(file, targetSize) {
+    const png = await sharp(Buffer.from(file.buffer, file.byteOffset, file.byteLength)).flatten({ background: "#ffffff" }).resize(targetSize, targetSize, { fit: "fill", kernel: sharp.kernel.nearest }).png().toBuffer();
+    return png;
+  },
+  async sha256Hex(input) {
+    return createHash("sha256").update(input).digest("hex");
+  }
+};
+
+// src/node.ts
+import { Buffer as Buffer2 } from "node:buffer";
+
+// src/recipe.ts
+import { z as z2 } from "zod";
+
+// src/core/imaging/index.ts
+var active = null;
+function imaging() {
+  if (!active) throw new Error("Imaging backend not installed: this entry point must call setImaging().");
+  return active;
+}
+
+// src/core/image.ts
+async function decodePng(file, path, label) {
+  try {
+    const raw = await imaging().decodePng(file);
+    return {
+      path,
+      file,
+      data: raw.data,
+      width: raw.width,
+      height: raw.height,
+      sha256: await imaging().sha256Hex(file)
+    };
+  } catch (error) {
+    throw new QrPosterError("INVALID_INPUT", `Could not decode ${label} as PNG: ${path}`, 2, { cause: error });
+  }
+}
+async function rgbaToPng(data, width, height) {
+  return imaging().encodePngRgba(data, width, height);
+}
+async function grayscaleToPng(data, width, height) {
+  return imaging().encodePngGrayscale(data, width, height);
+}
+function luma(r, g, b) {
+  return Math.round((299 * r + 587 * g + 114 * b) / 1e3);
+}
+
+// src/core/artifacts.ts
+function renderRegionMask(mask) {
+  return grayscaleToPng(mask.data, mask.width, mask.height);
+}
+
+// src/core/module-cut.ts
+function buildModuleLattice(width, height, modulePixels, origin) {
+  if (!Number.isInteger(modulePixels) || modulePixels < 1)
+    throw new QrPosterError("INVALID_INPUT", "The module pitch must be a positive integer.");
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1)
+    throw new QrPosterError("INVALID_INPUT", "The canvas must have positive integer dimensions.");
+  const phase = (value) => (Math.trunc(value) % modulePixels + modulePixels) % modulePixels;
+  const x = phase(origin.x);
+  const y = phase(origin.y);
+  return {
+    x,
+    y,
+    modulePixels,
+    columns: Math.ceil((width - x) / modulePixels),
+    rows: Math.ceil((height - y) / modulePixels),
+    width,
+    height
+  };
+}
+function moduleCellIndex(lattice, x, y) {
+  const column = Math.floor((x - lattice.x) / lattice.modulePixels);
+  const row = Math.floor((y - lattice.y) / lattice.modulePixels);
+  if (column < 0 || row < 0 || column >= lattice.columns || row >= lattice.rows) return -1;
+  return row * lattice.columns + column;
+}
+function computeSafeArea(selection, width, height, lattice) {
+  if (selection.length !== width * height)
+    throw new QrPosterError("IMAGE_PROCESSING_FAILED", "The cut selection does not match its dimensions.", 3);
+  const pitch = lattice.modulePixels;
+  const safe = new Uint8Array(lattice.columns * lattice.rows);
+  let safeModules = 0;
+  let partialModules = 0;
+  let droppedPartialPixels = 0;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let row = 0; row < lattice.rows; row++) {
+    for (let column = 0; column < lattice.columns; column++) {
+      const originX = lattice.x + column * pitch;
+      const originY = lattice.y + row * pitch;
+      let inside = 0;
+      let block = 0;
+      for (let offsetY = 0; offsetY < pitch; offsetY++) {
+        const y = originY + offsetY;
+        if (y < 0 || y >= height) continue;
+        for (let offsetX = 0; offsetX < pitch; offsetX++) {
+          const x = originX + offsetX;
+          if (x < 0 || x >= width) continue;
+          block++;
+          if (selection[y * width + x]) inside++;
+        }
+      }
+      if (block === pitch * pitch && inside === block) {
+        safe[row * lattice.columns + column] = 1;
+        safeModules++;
+        minX = Math.min(minX, originX);
+        minY = Math.min(minY, originY);
+        maxX = Math.max(maxX, originX + pitch);
+        maxY = Math.max(maxY, originY + pitch);
+        continue;
+      }
+      if (inside > 0) {
+        partialModules++;
+        droppedPartialPixels += inside;
+      }
+    }
+  }
+  return {
+    safe,
+    safeModules,
+    partialModules,
+    droppedPartialPixels,
+    bounds: safeModules === 0 ? { x: 0, y: 0, width: 0, height: 0 } : { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+  };
+}
+function computeTightBlockQuietZone(selection, width, height, safe, plate, lattice, placement, enabled) {
+  const cells = new Uint8Array(safe.length);
+  if (!enabled || selection.length !== width * height || safe.length !== lattice.columns * lattice.rows || plate.length !== safe.length || placement.size <= 0) {
+    return { cells, modules: 0 };
+  }
+  let minX = width;
+  let minY = height;
+  let maxX = 0;
+  let maxY = 0;
+  let selectedPixels = 0;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (!selection[y * width + x]) continue;
+      selectedPixels++;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x + 1);
+      maxY = Math.max(maxY, y + 1);
+    }
+  }
+  if (selectedPixels === 0) return { cells, modules: 0 };
+  const regionArea = (maxX - minX) * (maxY - minY);
+  if (selectedPixels !== regionArea) return { cells, modules: 0 };
+  const pitch = lattice.modulePixels;
+  const leftGap = placement.x - minX;
+  const topGap = placement.y - minY;
+  const rightGap = maxX - (placement.x + placement.size);
+  const bottomGap = maxY - (placement.y + placement.size);
+  if ([leftGap, topGap, rightGap, bottomGap].some((gap) => gap < 0 || gap >= pitch)) return { cells, modules: 0 };
+  let modules = 0;
+  for (let index = 0; index < safe.length; index++) {
+    if (!safe[index] || plate[index]) continue;
+    const row = Math.floor(index / lattice.columns);
+    const column = index - row * lattice.columns;
+    const x = lattice.x + column * pitch;
+    const y = lattice.y + row * pitch;
+    if (x < placement.x || y < placement.y || x + pitch > placement.x + placement.size || y + pitch > placement.y + placement.size)
+      continue;
+    cells[index] = 1;
+    modules++;
+  }
+  return { cells, modules };
+}
+function computePlateModules(lattice, plateRects, handbackRects = []) {
+  const pitch = lattice.modulePixels;
+  if (plateRects.length === 0) throw new QrPosterError("INVALID_INPUT", "The QR plate needs at least one rectangle.");
+  for (const rect of [...plateRects, ...handbackRects]) {
+    if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite))
+      throw new QrPosterError("INVALID_INPUT", "The QR plate rectangles must use finite numbers.");
+    if (rect.width <= 0 || rect.height <= 0)
+      throw new QrPosterError("INVALID_INPUT", "The QR plate rectangles must have a positive size.");
+  }
+  const cells = new Uint8Array(lattice.columns * lattice.rows);
+  const corners = new Uint8Array(lattice.columns * lattice.rows);
+  let holeModules = 0;
+  for (const rect of plateRects) {
+    const firstColumn = Math.ceil((rect.x - lattice.x) / pitch);
+    const firstRow = Math.ceil((rect.y - lattice.y) / pitch);
+    const lastColumn = Math.floor((rect.x + rect.width - lattice.x) / pitch) - 1;
+    const lastRow = Math.floor((rect.y + rect.height - lattice.y) / pitch) - 1;
+    for (let row = firstRow; row <= lastRow; row++) {
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        if (column < 0 || row < 0 || column >= lattice.columns || row >= lattice.rows) continue;
+        const index = row * lattice.columns + column;
+        if (cells[index]) continue;
+        cells[index] = 1;
+        holeModules++;
+      }
+    }
+  }
+  let cornerCount = 0;
+  for (const rect of handbackRects) {
+    const firstColumn = Math.ceil((rect.x - lattice.x) / pitch);
+    const firstRow = Math.ceil((rect.y - lattice.y) / pitch);
+    const lastColumn = Math.floor((rect.x + rect.width - lattice.x) / pitch) - 1;
+    const lastRow = Math.floor((rect.y + rect.height - lattice.y) / pitch) - 1;
+    for (let row = firstRow; row <= lastRow; row++) {
+      for (let column = firstColumn; column <= lastColumn; column++) {
+        if (column < 0 || row < 0 || column >= lattice.columns || row >= lattice.rows) continue;
+        const index = row * lattice.columns + column;
+        if (cells[index]) {
+          cells[index] = 0;
+          holeModules--;
+        }
+        if (corners[index]) {
+          continue;
+        }
+        corners[index] = 1;
+        cornerCount++;
+      }
+    }
+  }
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (let row = 0; row < lattice.rows; row++) {
+    for (let column = 0; column < lattice.columns; column++) {
+      if (!cells[row * lattice.columns + column]) continue;
+      const x = lattice.x + column * pitch;
+      const y = lattice.y + row * pitch;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x + pitch);
+      maxY = Math.max(maxY, y + pitch);
+    }
+  }
+  return {
+    cells,
+    corners,
+    holeModules,
+    cornerModules: cornerCount,
+    bounds: holeModules === 0 ? { x: 0, y: 0, width: 0, height: 0 } : { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+  };
+}
+function computeRimModules(safe, lattice, rimModules) {
+  const { columns, rows } = lattice;
+  const rim = new Uint8Array(columns * rows);
+  if (!Number.isInteger(rimModules) || rimModules < 1) return rim;
+  const distance = new Int32Array(columns * rows).fill(-1);
+  const queue = [];
+  for (let index = 0; index < safe.length; index++) {
+    if (safe[index]) continue;
+    distance[index] = 0;
+    queue.push(index);
+  }
+  for (let head = 0; head < queue.length; head++) {
+    const index = queue[head];
+    const distance_ = distance[index];
+    const next = distance_ + 1;
+    if (next > rimModules) continue;
+    const row = Math.floor(index / columns);
+    const column = index - row * columns;
+    for (let deltaY = -1; deltaY <= 1; deltaY++) {
+      const neighbourRow = row + deltaY;
+      if (neighbourRow < 0 || neighbourRow >= rows) continue;
+      for (let deltaX = -1; deltaX <= 1; deltaX++) {
+        const neighbourColumn = column + deltaX;
+        if (neighbourColumn < 0 || neighbourColumn >= columns) continue;
+        const neighbour = neighbourRow * columns + neighbourColumn;
+        if (distance[neighbour] !== -1) continue;
+        distance[neighbour] = next;
+        queue.push(neighbour);
+      }
+    }
+  }
+  for (let index = 0; index < rim.length; index++) {
+    if (safe[index] && distance[index] >= 0) rim[index] = 1;
+  }
+  return rim;
+}
+function computeRegionBands(safe, lattice, rimModules, regionMargin) {
+  const margin = new Uint8Array(safe.length);
+  if (!regionMargin) return { margin, rim: computeRimModules(safe, lattice, rimModules) };
+  const firstRing = computeRimModules(safe, lattice, 1);
+  const outerRings = rimModules > 0 ? computeRimModules(safe, lattice, rimModules + 1) : firstRing;
+  const rim = new Uint8Array(safe.length);
+  for (let index = 0; index < safe.length; index++) {
+    if (!safe[index]) continue;
+    const row = Math.floor(index / lattice.columns);
+    const column = index - row * lattice.columns;
+    const edgeDistance = Math.min(column + 1, row + 1, lattice.columns - column, lattice.rows - row);
+    if (firstRing[index] || edgeDistance === 1) margin[index] = 1;
+    else if (rimModules > 0 && (outerRings[index] || edgeDistance <= rimModules + 1)) rim[index] = 1;
+  }
+  return { margin, rim };
+}
+function buildModulePath(cells, lattice) {
+  if (cells.length !== lattice.columns * lattice.rows)
+    throw new QrPosterError("IMAGE_PROCESSING_FAILED", "The module grid does not match the lattice.", 3);
+  const pitch = lattice.modulePixels;
+  const parts = [];
+  for (let row = 0; row < lattice.rows; row++) {
+    for (let column = 0; column < lattice.columns; column++) {
+      if (!cells[row * lattice.columns + column]) continue;
+      const x = lattice.x + column * pitch;
+      const y = lattice.y + row * pitch;
+      parts.push(`M${x},${y}h${pitch}v${pitch}h-${pitch}Z`);
+    }
+  }
+  if (parts.length === 0)
+    throw new QrPosterError("IMAGE_PROCESSING_FAILED", "The module cut path selects no modules.", 3);
+  return parts.join("");
+}
+async function renderModuleCoverage(pathData, width, height, allowAntialias = false) {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><path fill="#ffffff" d="${pathData}"/></svg>`;
+  const raster = await imaging().rasterizeSvg(svg, width, height);
+  const coverage = new Uint8Array(width * height);
+  for (let index = 0; index < coverage.length; index++) {
+    const alpha = raster.data[index * 4 + 3];
+    if (!allowAntialias && alpha !== 0 && alpha !== 255) {
+      throw new QrPosterError(
+        "IMAGE_PROCESSING_FAILED",
+        `The module cut rasterized a partial pixel (alpha ${alpha}); module edges must land on integer pixels.`,
+        3
+      );
+    }
+    coverage[index] = alpha;
+  }
+  return coverage;
+}
+
+// src/core/rotate.ts
+function canonicalizeRotation(deg) {
+  if (deg === void 0 || !Number.isFinite(deg)) return 0;
+  const normalized = deg % 360;
+  return normalized < 0 ? normalized + 360 : normalized;
+}
+function placementCenter(box) {
+  return { x: box.x + box.size / 2, y: box.y + box.size / 2 };
+}
+function placementInverse(box) {
+  const radians = canonicalizeRotation(box.rotation) * Math.PI / 180;
+  const center = placementCenter(box);
+  return {
+    centerX: center.x,
+    centerY: center.y,
+    size: box.size,
+    cos: Math.cos(radians),
+    sin: Math.sin(radians)
+  };
+}
+function forwardMap(inv, localX, localY) {
+  const dx = localX - inv.size / 2;
+  const dy = localY - inv.size / 2;
+  return {
+    x: inv.centerX + dx * inv.cos - dy * inv.sin,
+    y: inv.centerY + dx * inv.sin + dy * inv.cos
+  };
+}
+function inverseMap(inv, posterX, posterY) {
+  const dx = posterX - inv.centerX;
+  const dy = posterY - inv.centerY;
+  return {
+    x: inv.size / 2 + dx * inv.cos + dy * inv.sin,
+    y: inv.size / 2 - dx * inv.sin + dy * inv.cos
+  };
+}
+function plateToPosterPoint(localX, localY, box) {
+  return forwardMap(placementInverse(box), localX, localY);
+}
+function posterToPlatePoint(posterX, posterY, box) {
+  return inverseMap(placementInverse(box), posterX, posterY);
+}
+function rotatedSquareCorners(box) {
+  return [
+    plateToPosterPoint(0, 0, box),
+    plateToPosterPoint(box.size, 0, box),
+    plateToPosterPoint(box.size, box.size, box),
+    plateToPosterPoint(0, box.size, box)
+  ];
+}
+function rotatedFootprintBounds(box, width, height) {
+  const corners = rotatedSquareCorners(box);
+  const minX = Math.min(...corners.map((corner) => corner.x));
+  const minY = Math.min(...corners.map((corner) => corner.y));
+  const maxX = Math.max(...corners.map((corner) => corner.x));
+  const maxY = Math.max(...corners.map((corner) => corner.y));
+  return {
+    left: Math.max(0, Math.floor(minX)),
+    top: Math.max(0, Math.floor(minY)),
+    right: Math.min(width, Math.ceil(maxX)),
+    bottom: Math.min(height, Math.ceil(maxY))
+  };
+}
+function qrWorkingFrame(placement, regionBounds) {
+  const corners = [
+    posterToPlatePoint(regionBounds.x0, regionBounds.y0, placement),
+    posterToPlatePoint(regionBounds.x1, regionBounds.y0, placement),
+    posterToPlatePoint(regionBounds.x1, regionBounds.y1, placement),
+    posterToPlatePoint(regionBounds.x0, regionBounds.y1, placement)
+  ];
+  const minX = Math.min(...corners.map((corner) => corner.x));
+  const minY = Math.min(...corners.map((corner) => corner.y));
+  const maxX = Math.max(...corners.map((corner) => corner.x));
+  const maxY = Math.max(...corners.map((corner) => corner.y));
+  const left = Math.floor(minX);
+  const top = Math.floor(minY);
+  return {
+    left,
+    top,
+    width: Math.ceil(maxX) - left,
+    height: Math.ceil(maxY) - top,
+    qr: { x: -left, y: -top, size: placement.size }
+  };
+}
+function sampleMaskIntoQrFrame(mask, posterWidth, posterHeight, frame, placement) {
+  if (mask.length !== posterWidth * posterHeight)
+    throw new Error("sampleMaskIntoQrFrame: mask does not match the poster dimensions.");
+  const inv = placementInverse(placement);
+  const working = new Uint8Array(frame.width * frame.height);
+  for (let wy = 0; wy < frame.height; wy++) {
+    for (let wx = 0; wx < frame.width; wx++) {
+      const poster = forwardMap(inv, wx + frame.left + 0.5, wy + frame.top + 0.5);
+      const sourceX = Math.floor(poster.x);
+      const sourceY = Math.floor(poster.y);
+      if (sourceX < 0 || sourceY < 0 || sourceX >= posterWidth || sourceY >= posterHeight) continue;
+      if (mask[sourceY * posterWidth + sourceX]) working[wy * frame.width + wx] = 1;
+    }
+  }
+  return working;
+}
+function regionPixelBounds(mask) {
+  let x0 = mask.width;
+  let y0 = mask.height;
+  let x1 = 0;
+  let y1 = 0;
+  for (let y = 0; y < mask.height; y++) {
+    for (let x = 0; x < mask.width; x++) {
+      if (!mask.data[y * mask.width + x]) continue;
+      x0 = Math.min(x0, x);
+      y0 = Math.min(y0, y);
+      x1 = Math.max(x1, x + 1);
+      y1 = Math.max(y1, y + 1);
+    }
+  }
+  if (x1 === 0 || y1 === 0) throw new Error("regionPixelBounds: the region mask is empty.");
+  return { x0, y0, x1, y1 };
+}
+function localPointInPlate(localX, localY, size) {
+  return localX >= 0 && localY >= 0 && localX < size && localY < size;
+}
+function assertFrameHoldsPlacement(frame, placement, posterWidth, posterHeight) {
+  for (let y = 0; y < posterHeight; y++) {
+    for (let x = 0; x < posterWidth; x++) {
+      const local = posterToPlatePoint(x + 0.5, y + 0.5, placement);
+      if (!localPointInPlate(local.x, local.y, placement.size)) continue;
+      const wx = Math.floor(local.x - frame.left);
+      const wy = Math.floor(local.y - frame.top);
+      if (wx >= 0 && wy >= 0 && wx < frame.width && wy < frame.height) continue;
+      throw new QrPosterError(
+        "QR_LAYOUT_INVALID",
+        "The rotated working frame does not cover the placed QR plate; the placement would be clipped. Adjust the position, size, or rotation inside the painted region."
+      );
+    }
+  }
+}
+
+// src/core/pattern.ts
+import { QrCodeDataType, encode } from "uqr";
+
+// src/core/palette.ts
+var DEFAULT_PALETTE = { pixel: "#000000", marker: "#000000", background: "#ffffff" };
+var GUARD = {
+  /** Rec.601 luma a selectable background must stay above (quiet-zone rule needs 200; kept headroom). */
+  lightLumaMin: 205,
+  /** Rec.601 luma every ink must stay at or below (INK_LUMA_THRESHOLD is 128; kept headroom). */
+  inkLumaMax: 120,
+  /** OKLCH lightness distance each ink must keep from the background. */
+  minLightnessDistance: 0.3
+};
+var HEX_PATTERN = /^#[0-9a-fA-F]{6}$/;
+function parseHex(hex) {
+  const value = hex.trim();
+  if (!HEX_PATTERN.test(value) && !/^#[0-9a-fA-F]{3}$/.test(value)) return null;
+  const body = value.slice(1);
+  const digits = body.length === 3 ? [...body].map((c) => c + c).join("") : body;
+  const channels = [0, 2, 4].map((start) => Number.parseInt(digits.slice(start, start + 2), 16));
+  if (channels.some((channel) => Number.isNaN(channel))) return null;
+  return [channels[0], channels[1], channels[2]];
+}
+function normalizeHex(hex) {
+  const rgb = parseHex(hex);
+  return rgb ? hexFromRgb(rgb) : null;
+}
+function hexFromRgb([r, g, b]) {
+  return `#${[r, g, b].map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+}
+function luma2([r, g, b]) {
+  return Math.round((299 * r + 587 * g + 114 * b) / 1e3);
+}
+function hexToRgb(hex) {
+  return parseHex(hex) ?? [0, 0, 0];
+}
+var LINEAR_SRGB_TO_LMS = [
+  [0.4122214708, 0.5363325363, 0.0514459929],
+  [0.2119034982, 0.6806995451, 0.1073969566],
+  [0.0883024619, 0.2817188376, 0.6299787005]
+];
+var LMS_CUBIC_TO_OKLAB = [
+  [0.2104542553, 0.793617785, -0.0040720468],
+  [1.9779984951, -2.428592205, 0.4505937099],
+  [0.0259040371, 0.7827717662, -0.808675766]
+];
+function mix(row, values) {
+  return row[0] * values[0] + row[1] * values[1] + row[2] * values[2];
+}
+function decodeSrgb(channel) {
+  const u = channel / 255;
+  return u <= 0.04045 ? u / 12.92 : ((u + 0.055) / 1.055) ** 2.4;
+}
+function rgbToOklch(rgb) {
+  const linear = [rgb[0], rgb[1], rgb[2]].map(decodeSrgb);
+  const lmsCubeRoots = LINEAR_SRGB_TO_LMS.map(
+    (row) => Math.cbrt(Math.max(0, mix(row, linear)))
+  );
+  const [L, a, b] = LMS_CUBIC_TO_OKLAB.map((row) => mix(row, lmsCubeRoots));
+  const c = Math.sqrt(a * a + b * b);
+  const h = (Math.atan2(b, a) * 180 / Math.PI + 360) % 360;
+  return { l: L, c, h };
+}
+function paletteGuard(palette) {
+  const issues = [];
+  const keys = ["pixel", "marker", "background"];
+  const colors = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    const rgb = normalizeHex(palette[key]) ? parseHex(palette[key]) : null;
+    colors.set(key, rgb);
+    if (!rgb) issues.push({ color: key, message: "Use a 6-digit hex color like #0b3d91." });
+  }
+  if (issues.length > 0) return { ok: false, issues };
+  const background = colors.get("background");
+  if (luma2(background) < GUARD.lightLumaMin)
+    issues.push({ color: "background", message: "The background is too dark to keep the QR light modules readable." });
+  const backgroundLightness = rgbToOklch(background).l;
+  for (const key of ["pixel", "marker"]) {
+    const rgb = colors.get(key);
+    if (luma2(rgb) > GUARD.inkLumaMax)
+      issues.push({ color: key, message: "This ink is too light to read as a dark module; pick a darker color." });
+    if (Math.abs(rgbToOklch(rgb).l - backgroundLightness) < GUARD.minLightnessDistance)
+      issues.push({
+        color: key,
+        message: "Not enough lightness separation from the background for reliable scanning."
+      });
+  }
+  return { ok: issues.length === 0, issues };
+}
+
+// src/core/pattern.ts
+var PATTERN_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+var PATTERN_ECC = "M";
+var PATTERN_PIXEL_STYLE = "dot";
+var PATTERN_PIXEL_STYLES = ["square", "rounded", "dot"];
+var PATTERN_MARKER_REFILL = "seeded-random";
+var PATTERN_INK = "#000000";
+var PATTERN_LIGHT = "#ffffff";
+var PATTERN_QUIET_ZONE_MODULES = 2;
+var QUIET_ZONE_MODULES = PATTERN_QUIET_ZONE_MODULES;
+var MAX_VERSION = 40;
+var REFILL_SEED_SALT = 2654435769;
+var WEDGE_RADIUS_PADDING = 2;
+function selectPatternVersion(modulePixels, width, height, headroomPixels = 0) {
+  const required = Math.max(width, height) + headroomPixels;
+  for (let version = 1; version <= MAX_VERSION; version++) {
+    if (totalModulesFor(version) * modulePixels >= required) return version;
+  }
+  const maxModules = totalModulesFor(MAX_VERSION);
+  throw new QrPosterError(
+    "QR_LAYOUT_INVALID",
+    `A ${modulePixels}px module pitch cannot cover the ${width}x${height} canvas: version ${MAX_VERSION} reaches only ${maxModules} modules (${maxModules * modulePixels}px including the ${QUIET_ZONE_MODULES}-module margin). Use --module-pixels ${Math.ceil(required / maxModules)} or larger.`
+  );
+}
+function createPatternText(version, seed) {
+  let length = patternCapacity(version);
+  while (length > 0) {
+    const random = mulberry32(seed);
+    let text = "";
+    for (let index = 0; index < length; index++)
+      text += PATTERN_ALPHABET[Math.floor(random() * PATTERN_ALPHABET.length)];
+    if (fitsVersion(text, version)) return text;
+    length--;
+  }
+  throw new QrPosterError("QR_INVALID", `Random text could not fill a version ${version} QR code.`);
+}
+function stripMarkerModules(matrix, seed) {
+  const random = mulberry32(markerRefillSeed(seed));
+  return matrix.data.map(
+    (row, y) => row.map((dark, x) => {
+      const type = matrix.types[y]?.[x] ?? QrCodeDataType.Data;
+      if (type === QrCodeDataType.Position || type === QrCodeDataType.Alignment) return random() < 0.5;
+      return dark;
+    })
+  );
+}
+function countMarkerModules(matrix) {
+  let count = 0;
+  for (let y = 0; y < matrix.size; y++) {
+    for (let x = 0; x < matrix.size; x++) {
+      const type = matrix.types[y]?.[x] ?? QrCodeDataType.Data;
+      if (type === QrCodeDataType.Position || type === QrCodeDataType.Alignment) count++;
+    }
+  }
+  return count;
+}
+function markerRefillSeed(seed) {
+  return (seed ^ REFILL_SEED_SALT) >>> 0;
+}
+async function renderPattern(matrix, modulePixels, pixelStyle = PATTERN_PIXEL_STYLE, options = {}) {
+  if (!Number.isInteger(modulePixels) || modulePixels < 1)
+    throw new QrPosterError("INVALID_INPUT", "modulePixels must be a positive integer.");
+  if (!PATTERN_PIXEL_STYLES.includes(pixelStyle))
+    throw new QrPosterError("INVALID_INPUT", `pixelStyle must be one of ${PATTERN_PIXEL_STYLES.join(", ")}.`);
+  if (matrix.length === 0 || matrix.some((row) => row.length !== matrix.length))
+    throw new QrPosterError("IMAGE_PROCESSING_FAILED", "Pattern matrix must be a non-empty square.", 3);
+  const marginModules = options.marginModules ?? QUIET_ZONE_MODULES;
+  const modules = matrix.length;
+  const totalModules = modules + marginModules * 2;
+  const codeSize = totalModules * modulePixels;
+  const window = options.window ?? { left: 0, top: 0, width: codeSize, height: codeSize };
+  if (window.left < 0 || window.top < 0 || window.width < 1 || window.height < 1 || window.left + window.width > codeSize || window.top + window.height > codeSize) {
+    throw new QrPosterError("IMAGE_PROCESSING_FAILED", "The pattern render window must fit inside the code canvas.", 3);
+  }
+  const include = options.include;
+  const skipInk = options.skipInk;
+  const included = (x, y) => {
+    if (x < 0 || y < 0 || x >= totalModules || y >= totalModules) return false;
+    return include === void 0 || include(x, y);
+  };
+  const dark = (x, y) => {
+    if (!included(x, y)) return false;
+    if (skipInk?.(x, y)) return false;
+    const column = x - marginModules;
+    const row = y - marginModules;
+    if (column < 0 || row < 0 || column >= modules || row >= modules) return false;
+    return matrix[row][column];
+  };
+  const backgroundMode = options.background ?? "white";
+  const ink = normalizeHex(options.ink ?? "") ?? PATTERN_INK;
+  const light = normalizeHex(options.light ?? "") ?? PATTERN_LIGHT;
+  const background = backgroundMode === "transparent" ? "" : include === void 0 ? `<rect width="${codeSize}" height="${codeSize}" fill="${light}"/>` : `<path fill="${light}" d="${includedCells(include, totalModules, modulePixels)}"/>`;
+  let foreground = "";
+  if (pixelStyle === "square") {
+    const rects = [];
+    for (let y = 0; y < totalModules; y++) {
+      for (let x = 0; x < totalModules; x++) {
+        if (!included(x, y)) continue;
+        if (skipInk?.(x, y)) continue;
+        if (!dark(x, y)) continue;
+        const ox = x * modulePixels;
+        const oy = y * modulePixels;
+        rects.push(`M${ox},${oy}h${modulePixels}v${modulePixels}h-${modulePixels}Z`);
+      }
+    }
+    foreground = `<path fill="${ink}" d="${rects.join("")}"/>`;
+  } else if (pixelStyle === "dot") {
+    const half = modulePixels / 2;
+    const circles = [];
+    for (let y = 0; y < totalModules; y++) {
+      for (let x = 0; x < totalModules; x++) {
+        if (!included(x, y)) continue;
+        if (skipInk?.(x, y)) continue;
+        if (!dark(x, y)) continue;
+        const ox = x * modulePixels;
+        const oy = y * modulePixels;
+        circles.push(
+          `M${ox},${oy + half}a${half},${half} 0 1 0 ${modulePixels},0a${half},${half} 0 1 0 ${-modulePixels},0Z`
+        );
+      }
+    }
+    foreground = `<path fill="${ink}" d="${circles.join("")}"/>`;
+  } else {
+    const half = modulePixels / 2;
+    const radius = half + WEDGE_RADIUS_PADDING;
+    const circles = [];
+    const wedges = [];
+    const wedge = (key, ox, oy) => {
+      const right = ox + modulePixels;
+      const bottom = oy + modulePixels;
+      const paths = {
+        tl: `M${ox},${oy} L${ox},${oy + half} A${radius},${radius} 0 0 1 ${ox + half},${oy} Z`,
+        tr: `M${right},${oy} L${right},${oy + half} A${radius},${radius} 0 0 0 ${right - half},${oy} Z`,
+        bl: `M${ox},${bottom} L${ox},${bottom - half} A${radius},${radius} 0 0 0 ${ox + half},${bottom} Z`,
+        br: `M${right},${bottom} L${right},${bottom - half} A${radius},${radius} 0 0 1 ${right - half},${bottom} Z`
+      };
+      wedges.push(paths[key]);
+    };
+    for (let y = 0; y < totalModules; y++) {
+      for (let x = 0; x < totalModules; x++) {
+        if (!included(x, y)) continue;
+        if (skipInk?.(x, y)) continue;
+        const ox = x * modulePixels;
+        const oy = y * modulePixels;
+        const up = dark(x, y - 1);
+        const down = dark(x, y + 1);
+        const left = dark(x - 1, y);
+        const right = dark(x + 1, y);
+        if (dark(x, y)) {
+          circles.push(
+            `M${ox},${oy + half}a${half},${half} 0 1 0 ${modulePixels},0a${half},${half} 0 1 0 ${-modulePixels},0Z`
+          );
+          if (up || left) wedge("tl", ox, oy);
+          if (up || right) wedge("tr", ox, oy);
+          if (down || left) wedge("bl", ox, oy);
+          if (down || right) wedge("br", ox, oy);
+        } else {
+          if (up && left && dark(x - 1, y - 1)) wedge("tl", ox, oy);
+          if (up && right && dark(x + 1, y - 1)) wedge("tr", ox, oy);
+          if (down && left && dark(x - 1, y + 1)) wedge("bl", ox, oy);
+          if (down && right && dark(x + 1, y + 1)) wedge("br", ox, oy);
+        }
+      }
+    }
+    foreground = `<path fill="${ink}" d="${circles.join("")}"/><path fill="${ink}" d="${wedges.join("")}"/>`;
+  }
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${window.width}" height="${window.height}" viewBox="${window.left} ${window.top} ${window.width} ${window.height}">` + background + foreground + "</svg>";
+  const rendered = await imaging().renderSvgToPng(svg, {
+    flatten: backgroundMode === "white" && include === void 0
+  });
+  if (rendered.width !== window.width || rendered.height !== window.height) {
+    throw new QrPosterError(
+      "IMAGE_PROCESSING_FAILED",
+      `Pattern rasterization produced ${rendered.width}x${rendered.height} instead of ${window.width}x${window.height}.`,
+      3
+    );
+  }
+  return rendered.png;
+}
+async function buildPosterPattern(options) {
+  const { width, height, modulePixels } = options;
+  if (!Number.isInteger(modulePixels) || modulePixels < 1)
+    throw new QrPosterError("INVALID_INPUT", "modulePixels must be a positive integer.");
+  const version = selectPatternVersion(modulePixels, width, height, options.alignTo === void 0 ? 0 : modulePixels);
+  const seed = options.seed ?? randomSeed();
+  const text = createPatternText(version, seed);
+  const encoded = encode(text, { ecc: PATTERN_ECC, minVersion: version, maxVersion: version, border: 0 });
+  if (encoded.version !== version)
+    throw new QrPosterError("QR_INVALID", `Encoder produced version ${encoded.version} instead of ${version}.`);
+  const matrix = stripMarkerModules(encoded, seed);
+  const totalModules = encoded.size + QUIET_ZONE_MODULES * 2;
+  const codeSize = totalModules * modulePixels;
+  const crop = centeredCrop(codeSize, width, height, modulePixels, options.alignTo);
+  return {
+    seed,
+    version,
+    text,
+    matrix,
+    qrModules: encoded.size,
+    totalModules,
+    codeSize,
+    marginModules: QUIET_ZONE_MODULES,
+    crop,
+    refilledModules: countMarkerModules(encoded)
+  };
+}
+function includedCells(include, totalModules, modulePixels) {
+  const parts = [];
+  for (let y = 0; y < totalModules; y++) {
+    for (let x = 0; x < totalModules; x++) {
+      if (!include(x, y)) continue;
+      parts.push(`M${x * modulePixels},${y * modulePixels}h${modulePixels}v${modulePixels}h-${modulePixels}Z`);
+    }
+  }
+  return parts.join("");
+}
+function totalModulesFor(version) {
+  return 21 + 4 * (version - 1) + QUIET_ZONE_MODULES * 2;
+}
+function patternCapacity(version) {
+  let low = 0;
+  let high = 3072;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (fitsVersion("a".repeat(middle), version)) low = middle;
+    else high = middle - 1;
+  }
+  return low;
+}
+function fitsVersion(text, version) {
+  try {
+    encode(text, { ecc: PATTERN_ECC, minVersion: version, maxVersion: version, border: 0 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+function centeredCrop(codeSize, width, height, modulePixels, alignTo) {
+  const offset = (extent, phase) => {
+    const raw = (codeSize - extent) / 2;
+    let aligned = Math.round(raw / modulePixels) * modulePixels;
+    if (phase !== void 0) {
+      const target = (-phase % modulePixels + modulePixels) % modulePixels;
+      const current = (aligned % modulePixels + modulePixels) % modulePixels;
+      let delta = ((target - current) % modulePixels + modulePixels) % modulePixels;
+      if (delta > modulePixels / 2) delta -= modulePixels;
+      aligned += delta;
+      if (!fits(aligned, extent, codeSize)) return fittingOffset(raw, extent, codeSize, modulePixels, target);
+    }
+    if (fits(aligned, extent, codeSize)) return aligned;
+    return fittingOffset(raw, extent, codeSize, modulePixels);
+  };
+  return { left: offset(width, alignTo?.x), top: offset(height, alignTo?.y) };
+}
+function fits(offset, extent, codeSize) {
+  return offset >= 0 && offset + extent <= codeSize;
+}
+function fittingOffset(raw, extent, codeSize, modulePixels, phase) {
+  const limit = codeSize - extent;
+  const base = Math.floor(raw / modulePixels) * modulePixels;
+  if (limit < 0) return base;
+  if (phase !== void 0) {
+    let best2 = -1;
+    for (let candidate = phase; candidate <= limit; candidate += modulePixels) {
+      if (best2 === -1 || Math.abs(candidate - raw) < Math.abs(best2 - raw)) best2 = candidate;
+    }
+    if (best2 !== -1) return best2;
+  }
+  let best = base;
+  for (const candidate of [base, base + modulePixels, base - modulePixels]) {
+    if (!fits(candidate, extent, codeSize)) continue;
+    if (Math.abs(candidate - raw) < Math.abs(best - raw)) best = candidate;
+  }
+  return best;
+}
+function randomSeed() {
+  return Math.floor(Math.random() * 2 ** 31);
+}
+
+// src/core/pattern-cut.ts
+var SVG_CLIP_ID = "pattern-cut";
+function format(value) {
+  const rounded = Math.round(value * 100) / 100;
+  return String(rounded === 0 ? 0 : rounded);
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let start = 0; start < bytes.length; start += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(start, start + 32768));
+  }
+  return btoa(binary);
+}
+function buildCutSvg(pathData, width, height, pattern, options = {}) {
+  const encoded = bytesToBase64(pattern);
+  const borderWidth = options.borderWidth ?? 0;
+  const border = borderWidth > 0 ? `  <path d="${pathData}" fill="none" stroke="#000000" stroke-width="${format(borderWidth * 2)}" fill-rule="evenodd" clip-rule="evenodd" clip-path="url(#${SVG_CLIP_ID})"/>
+` : "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <defs><clipPath id="${SVG_CLIP_ID}"><path fill-rule="evenodd" clip-rule="evenodd" d="${pathData}"/></clipPath></defs>
+  <image x="0" y="0" width="${width}" height="${height}" preserveAspectRatio="none" clip-path="url(#${SVG_CLIP_ID})" href="data:image/png;base64,${encoded}"/>
+` + border + "</svg>\n";
+}
+
+// src/core/imaging/pixels.ts
+function compositePixelOver(source, sourceOffset, destination, destinationOffset, sourceAlphaOverride) {
+  const sourceAlpha = (sourceAlphaOverride ?? source[sourceOffset + 3]) / 255;
+  if (sourceAlpha === 0) return;
+  const destinationAlpha = destination[destinationOffset + 3] / 255;
+  const outputAlpha = sourceAlpha + destinationAlpha * (1 - sourceAlpha);
+  if (outputAlpha === 0) {
+    destination.fill(0, destinationOffset, destinationOffset + 4);
+    return;
+  }
+  for (let channel = 0; channel < 3; channel++) {
+    const sourceValue = source[sourceOffset + channel];
+    const destinationValue = destination[destinationOffset + channel];
+    destination[destinationOffset + channel] = Math.round(
+      (sourceValue * sourceAlpha + destinationValue * destinationAlpha * (1 - sourceAlpha)) / outputAlpha
+    );
+  }
+  destination[destinationOffset + 3] = Math.round(outputAlpha * 255);
+}
+
+// src/core/qr.ts
+import * as zxing from "@zxing/library";
+import jsQR from "jsqr";
+import { QrCodeDataType as QrCodeDataType2, encode as encode2 } from "uqr";
+
+// src/core/squircle.ts
+var MAX_SUBDIVISION_DEPTH = 12;
+function squirclePath(cx, cy, radius) {
+  if (![cx, cy, radius].every(Number.isFinite) || radius <= 0) {
+    throw new RangeError("Squircle center and radius must be finite, with a positive radius.");
+  }
+  const pointAt = (angle) => {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return {
+      x: cx + Math.sign(cos) * Math.sqrt(Math.abs(cos)) * radius,
+      y: cy + Math.sign(sin) * Math.sqrt(Math.abs(sin)) * radius
+    };
+  };
+  const pointLineDistance = (point, start, end) => {
+    const dx = end.x - start.x;
+    const dy = end.y - start.y;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) return Math.hypot(point.x - start.x, point.y - start.y);
+    const position = Math.max(0, Math.min(1, ((point.x - start.x) * dx + (point.y - start.y) * dy) / lengthSquared));
+    return Math.hypot(point.x - (start.x + position * dx), point.y - (start.y + position * dy));
+  };
+  const points = [pointAt(0)];
+  const tolerance = radius * 1e-3;
+  const subdivide = (startAngle, endAngle, start, end, depth) => {
+    const middleAngle = (startAngle + endAngle) / 2;
+    const middle = pointAt(middleAngle);
+    if (depth >= MAX_SUBDIVISION_DEPTH || pointLineDistance(middle, start, end) <= tolerance) {
+      points.push(end);
+      return;
+    }
+    subdivide(startAngle, middleAngle, start, middle, depth + 1);
+    subdivide(middleAngle, endAngle, middle, end, depth + 1);
+  };
+  for (let quadrant = 0; quadrant < 4; quadrant++) {
+    const startAngle = quadrant * Math.PI / 2;
+    const endAngle = (quadrant + 1) * Math.PI / 2;
+    subdivide(startAngle, endAngle, pointAt(startAngle), pointAt(endAngle), 0);
+  }
+  const format2 = (value) => Number(value.toFixed(4)).toString();
+  return points.map((point, index) => `${index === 0 ? "M" : "L"}${format2(point.x)} ${format2(point.y)}`).join(" ").concat(" Z");
+}
+
+// src/core/qr.ts
+var { BinaryBitmap, DecodeHintType, HybridBinarizer, QRCodeReader, RGBLuminanceSource } = zxing.default ?? zxing;
+var QUIET_ZONE_MODULES2 = 2;
+var MIN_VERSION = 1;
+var MAX_VERSION2 = 40;
+var GENERATED_QR_MODULE_PIXELS = 20;
+var GENERATED_QR_PATH = "<generated>";
+async function generateQrFromContent(content, ecc = "M", pixelStyle = PATTERN_PIXEL_STYLE, markerStyle = "rounded", markerShape = "circle", markerInner = "circle", markerSub = "square", finderMarkers, palette = DEFAULT_PALETTE) {
+  if (content.trim().length === 0)
+    throw new QrPosterError("INVALID_INPUT", "--content must not be empty or whitespace-only.");
+  if (/\r|\n/.test(content)) throw new QrPosterError("INVALID_INPUT", "--content must contain exactly one line.");
+  let encoded;
+  try {
+    encoded = encode2(content, { ecc, maskPattern: -1, border: 0 });
+  } catch (error) {
+    throw new QrPosterError(
+      "QR_INVALID",
+      "Could not encode --content as a QR code. The content may exceed the QR capacity.",
+      2,
+      { cause: error }
+    );
+  }
+  const marginModules = QUIET_ZONE_MODULES2;
+  const pitch = GENERATED_QR_MODULE_PIXELS;
+  const size = encoded.size;
+  const basePng = await renderPattern(encoded.data, pitch, pixelStyle, {
+    ink: palette.pixel,
+    light: palette.background,
+    skipInk: (moduleX, moduleY) => {
+      const x = moduleX - marginModules;
+      const y = moduleY - marginModules;
+      if (x < 0 || y < 0 || x >= size || y >= size) return false;
+      const t = encoded.types[y]?.[x];
+      if (t === QrCodeDataType2.Position) return true;
+      if (t === QrCodeDataType2.Alignment && markerSub === "circle") return true;
+      return false;
+    }
+  });
+  const overlays = [];
+  const fallback = { style: markerStyle, shape: markerShape, inner: markerInner };
+  const finderSvg = buildFinderSvg(
+    size,
+    pitch,
+    marginModules,
+    finderMarkers ?? { tl: fallback, tr: fallback, bl: fallback },
+    palette
+  );
+  if (finderSvg) overlays.push(finderSvg);
+  if (markerSub === "circle") {
+    const alignmentSvg = buildAlignmentSvg(encoded, pitch, marginModules, palette);
+    if (alignmentSvg) overlays.push(alignmentSvg);
+  }
+  const file = await imaging().composeQrPng(basePng, overlays);
+  return {
+    image: await decodePng(file, GENERATED_QR_PATH, "generated QR"),
+    version: encoded.version
+  };
+}
+function buildFinderSvg(modules, pitch, marginModules, markers, palette) {
+  const { marker: ink, background: light } = palette;
+  const size = (modules + marginModules * 2) * pitch;
+  const origins = [
+    ["tl", 0, 0],
+    ["tr", modules - 7, 0],
+    ["bl", 0, modules - 7]
+  ];
+  const parts = [];
+  for (const [id, x, y] of origins) {
+    const { shape, inner, style } = markers[id];
+    const rounded = style === "rounded";
+    const ox = (marginModules + x) * pitch;
+    const oy = (marginModules + y) * pitch;
+    const cx = ox + 3.5 * pitch;
+    const cy = oy + 3.5 * pitch;
+    if (shape === "square") {
+      const rx = rounded ? pitch * 0.35 : 0;
+      parts.push(
+        `<rect x="${ox}" y="${oy}" width="${7 * pitch}" height="${7 * pitch}" fill="${ink}" rx="${rx}" ry="${rx}"/>`
+      );
+      parts.push(
+        `<rect x="${ox + pitch}" y="${oy + pitch}" width="${5 * pitch}" height="${5 * pitch}" fill="${light}" rx="${rx * 0.6}" ry="${rx * 0.6}"/>`
+      );
+      if (inner === "square") {
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 1.5 * pitch}" width="${3 * pitch}" height="${3 * pitch}" fill="${ink}" rx="${rx * 0.5}" ry="${rx * 0.5}"/>`
+        );
+      } else if (inner === "circle") {
+        parts.push(`<circle cx="${cx}" cy="${cy}" r="${1.5 * pitch}" fill="${ink}"/>`);
+      } else if (inner === "plus") {
+        parts.push(
+          `<rect x="${cx - 0.5 * pitch}" y="${cy - 1.5 * pitch}" width="${pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 0.5 * pitch}" width="${3 * pitch}" height="${pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "diamond") {
+        parts.push(
+          `<polygon points="${cx},${cy - 1.5 * pitch} ${cx + 1.5 * pitch},${cy} ${cx},${cy + 1.5 * pitch} ${cx - 1.5 * pitch},${cy}" fill="${ink}"/>`
+        );
+      } else if (inner === "squircle") {
+        parts.push(`<path d="${squirclePath(cx, cy, 1.5 * pitch)}" fill="${ink}"/>`);
+      }
+    } else if (shape === "circle") {
+      parts.push(`<circle cx="${cx}" cy="${cy}" r="${3.5 * pitch}" fill="${ink}"/>`);
+      parts.push(`<circle cx="${cx}" cy="${cy}" r="${2.5 * pitch}" fill="${light}"/>`);
+      if (inner === "square") {
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 1.5 * pitch}" width="${3 * pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "circle") {
+        parts.push(`<circle cx="${cx}" cy="${cy}" r="${1.5 * pitch}" fill="${ink}"/>`);
+      } else if (inner === "plus") {
+        parts.push(
+          `<rect x="${cx - 0.5 * pitch}" y="${cy - 1.5 * pitch}" width="${pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 0.5 * pitch}" width="${3 * pitch}" height="${pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "diamond") {
+        parts.push(
+          `<polygon points="${cx},${cy - 1.5 * pitch} ${cx + 1.5 * pitch},${cy} ${cx},${cy + 1.5 * pitch} ${cx - 1.5 * pitch},${cy}" fill="${ink}"/>`
+        );
+      } else if (inner === "squircle") {
+        parts.push(`<path d="${squirclePath(cx, cy, 1.5 * pitch)}" fill="${ink}"/>`);
+      }
+    } else if (shape === "octagon") {
+      const outer = octagonPoints(cx, cy, 3.5 * pitch);
+      const innerWhite = octagonPoints(cx, cy, 2.5 * pitch);
+      parts.push(`<polygon points="${outer}" fill="${ink}"/>`);
+      parts.push(`<polygon points="${innerWhite}" fill="${light}"/>`);
+      if (inner === "square") {
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 1.5 * pitch}" width="${3 * pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "circle") {
+        parts.push(`<circle cx="${cx}" cy="${cy}" r="${1.5 * pitch}" fill="${ink}"/>`);
+      } else if (inner === "plus") {
+        parts.push(
+          `<rect x="${cx - 0.5 * pitch}" y="${cy - 1.5 * pitch}" width="${pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 0.5 * pitch}" width="${3 * pitch}" height="${pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "diamond") {
+        parts.push(
+          `<polygon points="${cx},${cy - 1.5 * pitch} ${cx + 1.5 * pitch},${cy} ${cx},${cy + 1.5 * pitch} ${cx - 1.5 * pitch},${cy}" fill="${ink}"/>`
+        );
+      } else if (inner === "squircle") {
+        parts.push(`<path d="${squirclePath(cx, cy, 1.5 * pitch)}" fill="${ink}"/>`);
+      }
+    } else if (shape === "squircle") {
+      parts.push(`<path d="${squirclePath(cx, cy, 3.5 * pitch)}" fill="${ink}"/>`);
+      parts.push(`<path d="${squirclePath(cx, cy, 2.5 * pitch)}" fill="${light}"/>`);
+      if (inner === "square") {
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 1.5 * pitch}" width="${3 * pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "circle") {
+        parts.push(`<circle cx="${cx}" cy="${cy}" r="${1.5 * pitch}" fill="${ink}"/>`);
+      } else if (inner === "plus") {
+        parts.push(
+          `<rect x="${cx - 0.5 * pitch}" y="${cy - 1.5 * pitch}" width="${pitch}" height="${3 * pitch}" fill="${ink}"/>`
+        );
+        parts.push(
+          `<rect x="${cx - 1.5 * pitch}" y="${cy - 0.5 * pitch}" width="${3 * pitch}" height="${pitch}" fill="${ink}"/>`
+        );
+      } else if (inner === "diamond") {
+        parts.push(
+          `<polygon points="${cx},${cy - 1.5 * pitch} ${cx + 1.5 * pitch},${cy} ${cx},${cy + 1.5 * pitch} ${cx - 1.5 * pitch},${cy}" fill="${ink}"/>`
+        );
+      } else {
+        parts.push(`<path d="${squirclePath(cx, cy, 1.5 * pitch)}" fill="${ink}"/>`);
+      }
+    }
+  }
+  if (parts.length === 0) return "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}">${parts.join("")}</svg>`;
+}
+function octagonPoints(cx, cy, size) {
+  const dx = 1.5 / 3.5 * size;
+  const dy = size;
+  const pts = [
+    [dx, dy],
+    [-dx, dy],
+    [-dy, dx],
+    [-dy, -dx],
+    [-dx, -dy],
+    [dx, -dy],
+    [dy, -dx],
+    [dy, dx]
+  ];
+  return pts.map(([x, y]) => `${cx + x},${cy + y}`).join(" ");
+}
+function buildAlignmentSvg(encoded, pitch, marginModules, palette) {
+  const { marker: ink, background: light } = palette;
+  const size = encoded.size;
+  const total = (size + marginModules * 2) * pitch;
+  const visited = /* @__PURE__ */ new Set();
+  const blocks = [];
+  const isAlignment = (x, y) => encoded.types[y]?.[x] === QrCodeDataType2.Alignment;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (!isAlignment(x, y) || visited.has(`${x},${y}`)) continue;
+      const queue = [[x, y]];
+      visited.add(`${x},${y}`);
+      let minX = x, maxX = x, minY = y, maxY = y;
+      let idx = 0;
+      while (idx < queue.length) {
+        const [cx, cy] = queue[idx++];
+        const neighbours = [
+          [cx - 1, cy],
+          [cx + 1, cy],
+          [cx, cy - 1],
+          [cx, cy + 1]
+        ];
+        for (const [nx, ny] of neighbours) {
+          if (nx < 0 || ny < 0 || nx >= size || ny >= size) continue;
+          if (!isAlignment(nx, ny) || visited.has(`${nx},${ny}`)) continue;
+          visited.add(`${nx},${ny}`);
+          queue.push([nx, ny]);
+          if (nx < minX) minX = nx;
+          if (nx > maxX) maxX = nx;
+          if (ny < minY) minY = ny;
+          if (ny > maxY) maxY = ny;
+        }
+      }
+      if (maxX - minX === 4 && maxY - minY === 4) blocks.push({ minX, minY });
+    }
+  }
+  if (blocks.length === 0) return null;
+  const parts = [];
+  for (const { minX, minY } of blocks) {
+    const cx = (marginModules + minX + 2.5) * pitch;
+    const cy = (marginModules + minY + 2.5) * pitch;
+    parts.push(`<circle cx="${cx}" cy="${cy}" r="${2.5 * pitch}" fill="${ink}"/>`);
+    parts.push(`<circle cx="${cx}" cy="${cy}" r="${1.5 * pitch}" fill="${light}"/>`);
+    parts.push(`<circle cx="${cx}" cy="${cy}" r="${0.5 * pitch}" fill="${ink}"/>`);
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${total}" height="${total}">${parts.join("")}</svg>`;
+}
+async function decodeQrBufferDetailed(buffer) {
+  const { data, width, height } = await imaging().decodePng(buffer);
+  return decodeQrRawDetailed(data, width, height);
+}
+function decodeQrRawDetailed(data, width, height) {
+  const pixels = Uint8ClampedArray.from(data);
+  const decoded = jsQR(pixels, width, height, { inversionAttempts: "attemptBoth" });
+  if (decoded) return { text: decoded.data, decoder: "jsqr", version: decoded.version };
+  try {
+    const luminances = new Uint8ClampedArray(width * height);
+    for (let i = 0; i < luminances.length; i++)
+      luminances[i] = luma(pixels[i * 4], pixels[i * 4 + 1], pixels[i * 4 + 2]);
+    const source = new RGBLuminanceSource(luminances, width, height);
+    const bitmap = new BinaryBitmap(new HybridBinarizer(source));
+    const hints = /* @__PURE__ */ new Map([
+      [DecodeHintType.TRY_HARDER, true],
+      [DecodeHintType.CHARACTER_SET, "UTF-8"]
+    ]);
+    return { text: new QRCodeReader().decode(bitmap, hints).getText(), decoder: "zxing" };
+  } catch (cause) {
+    throw new QrPosterError("QR_INVALID", "The QR code could not be decoded by ZXing or jsQR.", 2, { cause });
+  }
+}
+function inspectQrSource(image, decodedText, detectedVersion) {
+  if (image.width !== image.height)
+    throw new QrPosterError("QR_INVALID", `QR image must be square; received ${image.width}x${image.height}.`);
+  const candidates = quietZoneProfileCandidates(image, detectedVersion);
+  if (candidates.length !== 1) {
+    throw new QrPosterError(
+      "QR_INVALID",
+      `QR dimensions do not uniquely match the two-module quiet-zone profile (found ${candidates.length} candidates).`
+    );
+  }
+  const candidate = candidates[0];
+  return {
+    width: image.width,
+    height: image.height,
+    decodedText,
+    version: candidate.version,
+    qrModules: candidate.qrModules,
+    quietZoneModules: QUIET_ZONE_MODULES2,
+    totalModules: candidate.totalModules,
+    sourceModulePixels: candidate.cell,
+    quietZoneLightRatio: candidate.lightRatio
+  };
+}
+function quietZoneProfileCandidates(image, detectedVersion) {
+  const candidates = [];
+  for (let version = MIN_VERSION; version <= MAX_VERSION2; version++) {
+    const qrModules = 21 + 4 * (version - 1);
+    const totalModules = qrModules + QUIET_ZONE_MODULES2 * 2;
+    if (image.width % totalModules !== 0) continue;
+    const cell = image.width / totalModules;
+    const lightRatio = quietZoneLightRatio(image.data, image.width, image.height, QUIET_ZONE_MODULES2 * cell);
+    if (cell >= 1 && lightRatio >= 0.98 && (detectedVersion === void 0 || version === detectedVersion))
+      candidates.push({ version, qrModules, totalModules, cell, lightRatio });
+  }
+  return candidates;
+}
+async function normalizeQr(image, targetSize) {
+  return imaging().normalizeQrPng(image.file, targetSize);
+}
+async function transparentQrBackground(png, palette = DEFAULT_PALETTE) {
+  const image = await imaging().decodePng(png);
+  const pixels = Uint8Array.from(image.data);
+  const lightLuma = luma(...hexToRgb(palette.background));
+  const inkLuma = Math.max(luma(...hexToRgb(palette.pixel)), luma(...hexToRgb(palette.marker)));
+  const span = Math.max(1, lightLuma - inkLuma);
+  for (let offset = 0; offset < pixels.length; offset += 4) {
+    const luminance = Math.round((299 * pixels[offset] + 587 * pixels[offset + 1] + 114 * pixels[offset + 2]) / 1e3);
+    const scaled = Math.round(255 * (lightLuma - luminance) / span);
+    pixels[offset + 3] = Math.min(pixels[offset + 3], clampByte(scaled));
+  }
+  return imaging().encodePngRgba(pixels, image.width, image.height);
+}
+function clampByte(value) {
+  return Math.min(255, Math.max(0, value));
+}
+async function verifyQrVariant(name, buffer, expectedText) {
+  try {
+    const decoded = await decodeQrBufferDetailed(buffer);
+    if (decoded.text !== expectedText) {
+      return {
+        name,
+        passed: false,
+        decodedText: decoded.text,
+        decoder: decoded.decoder,
+        ...decoded.version !== void 0 ? { version: decoded.version } : {},
+        error: `Decoded content differs from the expected text.`
+      };
+    }
+    return {
+      name,
+      passed: true,
+      decodedText: decoded.text,
+      decoder: decoded.decoder,
+      ...decoded.version !== void 0 ? { version: decoded.version } : {}
+    };
+  } catch (error) {
+    return {
+      name,
+      passed: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function quietZoneLightRatio(data, width, height, marginPixels) {
+  let light = 0;
+  let total = 0;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (x >= marginPixels && x < width - marginPixels && y >= marginPixels && y < height - marginPixels) continue;
+      const offset = (y * width + x) * 4;
+      const alpha = data[offset + 3];
+      const brightness = luma(data[offset], data[offset + 1], data[offset + 2]);
+      if (alpha < 16 || brightness >= 200) light++;
+      total++;
+    }
+  }
+  return total === 0 ? 0 : light / total;
+}
+
+// src/core/assemble.ts
+var QUIET_ZONE_MODULES3 = PATTERN_QUIET_ZONE_MODULES;
+var BAND_MODULES = 1;
+var MARKER_MODULES = 7;
+var DEFAULT_RIM_MODULES = 1;
+var PLATE_CORNER_EPSILON = 0.01;
+var SKIPPED_DECODE_CHECKS = ["poster", "posterHalfScale", "posterJpeg80"];
+var REMOVED_TYPES = ["Position", "Alignment"];
+var ARTIFACT_NAMES = {
+  poster: "poster.png",
+  regionMask: "region-mask.png",
+  qr: "qr.png",
+  patternCutPng: "pattern-cut.png",
+  patternCutSvg: "pattern-cut.svg",
+  report: "report.json"
+};
+async function assembleResolved(layout, options) {
+  if ((layout.placement.rotation ?? 0) !== 0) return assembleRotated(layout, options);
+  return assembleUpright(layout, options);
+}
+async function assembleUpright(layout, options) {
+  const startedAt = Date.now();
+  const { poster, qrSource, maskInput, regionMask, decoded, qrMetadata, placement, normalizedQr } = layout;
+  const { width, height } = poster;
+  const pitch = placement.modulePixels;
+  const lattice = buildModuleLattice(width, height, pitch, placement);
+  const selection = Uint8Array.from(regionMask.data, (value) => value ? 1 : 0);
+  const safeArea = computeSafeArea(selection, width, height, lattice);
+  const marginModules = options.qrMargin ?? BAND_MODULES;
+  const marginPixels = marginModules * pitch;
+  const radius = options.radius ?? 2 * pitch;
+  const rimModulesCount = options.rimModules ?? DEFAULT_RIM_MODULES;
+  const rimRounded = options.rimRounded ?? false;
+  const transparentBlank = options.transparentBlank ?? false;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const light = hexToRgb(palette.background);
+  if (!Number.isInteger(rimModulesCount) || rimModulesCount < 0 || rimModulesCount > 5)
+    throw new QrPosterError("INVALID_INPUT", "rimModules must be an integer between 0 and 5.");
+  const codeGrid = {
+    x: placement.x + QUIET_ZONE_MODULES3 * pitch,
+    y: placement.y + QUIET_ZONE_MODULES3 * pitch,
+    width: qrMetadata.qrModules * pitch,
+    height: qrMetadata.qrModules * pitch
+  };
+  const { arms, cornerBlocks } = markerBandRects(codeGrid, qrMetadata.qrModules, pitch, marginModules);
+  const plateCornersCut = radius >= PLATE_CORNER_EPSILON;
+  const plate = computePlateModules(
+    lattice,
+    [codeGrid, ...arms, ...plateCornersCut ? [] : cornerBlocks],
+    plateCornersCut ? cornerBlocks : []
+  );
+  const bandCells = plate.holeModules - qrMetadata.qrModules * qrMetadata.qrModules;
+  const drawn = new Uint8Array(lattice.columns * lattice.rows);
+  let drawnModules = 0;
+  for (let index = 0; index < drawn.length; index++) {
+    if (!safeArea.safe[index] || plate.cells[index]) continue;
+    drawn[index] = 1;
+    drawnModules++;
+  }
+  const regionMargin = options.regionMargin ?? false;
+  const { margin, rim } = computeRegionBands(safeArea.safe, lattice, rimModulesCount, regionMargin);
+  const quietZone = computeTightBlockQuietZone(
+    selection,
+    width,
+    height,
+    safeArea.safe,
+    plate.cells,
+    lattice,
+    { x: placement.x, y: placement.y, size: placement.size },
+    rimModulesCount === 0
+  );
+  let rimModuleCount = 0;
+  let marginModuleCount = 0;
+  let regionMarginModuleCount = 0;
+  let textureModules = 0;
+  for (let index = 0; index < drawn.length; index++) {
+    if (!drawn[index]) continue;
+    if (margin[index]) regionMarginModuleCount++;
+    if (margin[index] || quietZone.cells[index]) marginModuleCount++;
+    else if (rim[index]) rimModuleCount++;
+    else textureModules++;
+  }
+  if (textureModules === 0 && (rimModulesCount > 0 || regionMargin) && quietZone.modules === 0) {
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      (regionMargin ? `The painted region leaves no texture module once the margin, ${rimModulesCount}-module rim, and QR plate ` : `The painted region leaves no texture module once the ${rimModulesCount}-module rim and the QR plate `) + "are removed. Use a larger region, a smaller QR box, or a manual --qr-box."
+    );
+  }
+  const pattern = await buildPosterPattern({
+    width,
+    height,
+    modulePixels: pitch,
+    alignTo: { x: placement.x, y: placement.y },
+    ...options.seed !== void 0 ? { seed: options.seed } : {}
+  });
+  const phaseX = ((pattern.crop.left + placement.x) % pitch + pitch) % pitch;
+  const phaseY = ((pattern.crop.top + placement.y) % pitch + pitch) % pitch;
+  if (phaseX !== 0 || phaseY !== 0) {
+    throw new QrPosterError(
+      "IMAGE_PROCESSING_FAILED",
+      `The texture window at ${pattern.crop.left},${pattern.crop.top} is not phase-locked to the ${pitch}px QR lattice (residual ${phaseX},${phaseY}); whole-module drawing needs both on one grid.`,
+      3
+    );
+  }
+  const moduleOffsetX = (pattern.crop.left + placement.x % pitch) / pitch;
+  const moduleOffsetY = (pattern.crop.top + placement.y % pitch) / pitch;
+  const matrixOffsetX = moduleOffsetX - pattern.marginModules;
+  const matrixOffsetY = moduleOffsetY - pattern.marginModules;
+  const effective = pattern.matrix.map((row) => row.slice());
+  for (let row = 0; row < lattice.rows; row++) {
+    for (let column = 0; column < lattice.columns; column++) {
+      const index = row * lattice.columns + column;
+      if (!drawn[index]) continue;
+      const matrixRow = row + matrixOffsetY;
+      const matrixColumn = column + matrixOffsetX;
+      if (matrixRow < 0 || matrixColumn < 0 || matrixRow >= effective.length || matrixColumn >= effective.length)
+        continue;
+      if (rim[index]) effective[matrixRow][matrixColumn] = true;
+    }
+  }
+  const include = (moduleX, moduleY) => {
+    const column = moduleX - moduleOffsetX;
+    const row = moduleY - moduleOffsetY;
+    if (column < 0 || row < 0 || column >= lattice.columns || row >= lattice.rows) return false;
+    return drawn[row * lattice.columns + column] === 1;
+  };
+  const pixelStyle = options.pixelStyle ?? PATTERN_PIXEL_STYLE;
+  let texturePng = await renderPattern(effective, pitch, pixelStyle, {
+    marginModules: pattern.marginModules,
+    window: { ...pattern.crop, width, height },
+    include,
+    ink: palette.pixel,
+    light: palette.background
+  });
+  const render = await decodePng(texturePng, "pattern.png", "rendered pattern");
+  const qrRaw = (await decodePng(normalizedQr, "normalized QR", "normalized QR")).data;
+  if (regionMargin) paintRegionMargin(render.data, width, lattice, drawn, margin, qrRaw);
+  if (quietZone.modules > 0) {
+    paintModuleCells(render.data, width, lattice, quietZone.cells, light);
+  }
+  if (regionMargin || quietZone.modules > 0) {
+    texturePng = await rgbaToPng(render.data, width, height);
+  }
+  const unitPath = buildModulePath(drawn, lattice);
+  const coverage = await renderModuleCoverage(unitPath, width, height, rimRounded);
+  const cutLayer = new Uint8Array(width * height * 4);
+  for (let index = 0; index < coverage.length; index++) {
+    const alpha = coverage[index];
+    if (alpha === 0) continue;
+    const offset = index * 4;
+    if (transparentBlank) {
+      const textureAlpha = Math.round(render.data[offset + 3] * alpha / 255);
+      if (textureAlpha === 0) continue;
+      cutLayer[offset] = render.data[offset];
+      cutLayer[offset + 1] = render.data[offset + 1];
+      cutLayer[offset + 2] = render.data[offset + 2];
+      cutLayer[offset + 3] = textureAlpha;
+      continue;
+    }
+    if (alpha === 255 || !rimRounded) {
+      cutLayer[offset] = render.data[offset];
+      cutLayer[offset + 1] = render.data[offset + 1];
+      cutLayer[offset + 2] = render.data[offset + 2];
+      cutLayer[offset + 3] = 255;
+    } else {
+      const srcA = alpha / 255;
+      cutLayer[offset] = Math.round(render.data[offset] * srcA + light[0] * (1 - srcA));
+      cutLayer[offset + 1] = Math.round(render.data[offset + 1] * srcA + light[1] * (1 - srcA));
+      cutLayer[offset + 2] = Math.round(render.data[offset + 2] * srcA + light[2] * (1 - srcA));
+      cutLayer[offset + 3] = alpha;
+    }
+  }
+  const cutPng = await rgbaToPng(cutLayer, width, height);
+  const cutSvg = buildCutSvg(unitPath, width, height, texturePng);
+  const output = Uint8Array.from(poster.data);
+  for (let row = 0; row < height; row++) {
+    for (let column = 0; column < width; column++) {
+      const index = row * width + column;
+      const offset = index * 4;
+      const cell = moduleCellIndex(lattice, column, row);
+      const source = cell >= 0 && plate.cells[cell] === 1 ? qrSourceOffset(placement, column, row) : null;
+      if (source !== null && source >= 0) {
+        for (let channel = 0; channel < 4; channel++) output[offset + channel] = qrRaw[source + channel];
+        continue;
+      }
+      const alpha = coverage[index];
+      if (alpha === 0) continue;
+      if (transparentBlank) {
+        const textureAlpha = Math.round(render.data[offset + 3] * alpha / 255);
+        if (textureAlpha > 0) compositePixelOver(render.data, offset, output, offset, textureAlpha);
+        continue;
+      }
+      if (alpha === 255 || !rimRounded) {
+        for (let channel = 0; channel < 3; channel++) output[offset + channel] = render.data[offset + channel];
+      } else {
+        const srcA = alpha / 255;
+        for (let channel = 0; channel < 3; channel++) {
+          const src = render.data[offset + channel];
+          const dst = output[offset + channel];
+          output[offset + channel] = Math.round(src * srcA + dst * (1 - srcA));
+        }
+      }
+    }
+  }
+  let outsidePassed = true;
+  let qrPassed = true;
+  let plateCornersPassed = true;
+  let moduleCutPassed = true;
+  let alphaPassed = true;
+  let transparentBackgroundPassed = true;
+  let cornerTexturePixels = 0;
+  for (let row = 0; row < height; row++) {
+    for (let column = 0; column < width; column++) {
+      const index = row * width + column;
+      const offset = index * 4;
+      const cell = moduleCellIndex(lattice, column, row);
+      const isPlate = cell >= 0 && plate.cells[cell] === 1;
+      const plateSource = isPlate ? qrSourceOffset(placement, column, row) : -1;
+      const isCorner = cell >= 0 && plate.corners[cell] === 1;
+      const isDrawn = cell >= 0 && drawn[cell] === 1;
+      const hasCoverage = coverage[index] > 0;
+      if (isCorner) cornerTexturePixels++;
+      let changed = false;
+      for (let channel = 0; channel < 4; channel++) {
+        const value = output[offset + channel];
+        if (value !== poster.data[offset + channel]) changed = true;
+        if (!regionMask.data[index] && value !== poster.data[offset + channel]) outsidePassed = false;
+        if (isPlate && value !== qrRaw[plateSource + channel]) qrPassed = false;
+        if (isCorner) {
+          const expected = transparentBlank && channel === 3 ? Math.round(render.data[offset + 3] * coverage[index] / 255) : render.data[offset + channel];
+          if (value !== expected) plateCornersPassed = false;
+        }
+      }
+      const allowed = rimRounded ? hasCoverage || isPlate : isDrawn || isPlate;
+      if (changed && !allowed) moduleCutPassed = false;
+      if (output[offset + 3] !== poster.data[offset + 3]) alphaPassed = false;
+      if (transparentBlank) {
+        const expectedAlpha = isPlate ? qrRaw[plateSource + 3] : Math.round(render.data[offset + 3] * coverage[index] / 255);
+        if (poster.data[offset + 3] !== 0 || output[offset + 3] !== expectedAlpha) transparentBackgroundPassed = false;
+      }
+    }
+  }
+  const assembled = await rgbaToPng(output, width, height);
+  const checks = [
+    {
+      name: "sourceQr",
+      passed: true,
+      decodedText: decoded.text,
+      decoder: decoded.decoder,
+      ...decoded.version !== void 0 ? { version: decoded.version } : {}
+    },
+    await verifyQrVariant("normalizedQr", normalizedQr, decoded.text),
+    { name: "outsideRegionPixels", passed: outsidePassed },
+    { name: "qrPixels", passed: qrPassed },
+    { name: "qrPlateCorners", passed: plateCornersPassed },
+    { name: "moduleCut", passed: moduleCutPassed },
+    ...transparentBlank ? [{ name: "transparentBackground", passed: transparentBackgroundPassed }] : [{ name: "alphaPreserved", passed: alphaPassed }]
+  ];
+  const qualified = checks.every((check) => check.passed);
+  const warnings = [];
+  warnings.push(
+    quietZone.modules > 0 ? `The ${QUIET_ZONE_MODULES3}-module QR quiet margin is kept light in this tight rectangular mask (${quietZone.modules} safe cells); the finder band is ${formatNumber(marginModules)} module deep (${marginPixels}px at ${pitch}px modules). The assembled poster is not decode-verified.` : `The light band is kept beside the three finder markers only: ${bandCells} cell(s) ${formatNumber(marginModules)} module deep (${marginPixels}px at ${pitch}px modules), with the plate's ${plate.cornerModules} corner block module(s) handed back to the texture. The code's other edges sit flush against the texture, so the profile's ${QUIET_ZONE_MODULES3}-module quiet zone is not kept and the assembled poster is not decode-verified; only the QR input and the geometry checks ran.`
+  );
+  if (regionMargin)
+    warnings.push(
+      `A one-module light margin follows the selected region inside its edge (${regionMarginModuleCount} whole modules).`
+    );
+  if (safeArea.partialModules > 0) {
+    warnings.push(
+      `${safeArea.partialModules} module(s) crossed the painted region's edge and kept the original artwork (${safeArea.droppedPartialPixels} region pixels); the cut draws whole modules only.`
+    );
+  }
+  if (pitch < 6) warnings.push(`The normalized QR uses ${pitch}px modules; 6px or larger is preferred.`);
+  for (const check of checks) {
+    if (!check.passed) warnings.push(`${check.name} verification failed${check.error ? `: ${check.error}` : "."}`);
+  }
+  const regionMaskPng = await renderRegionMask(regionMask);
+  const transparentQr = await transparentQrBackground(normalizedQr, palette);
+  const [posterSha, qrSha, cutPngSha, cutSvgSha, textSha] = await Promise.all([
+    imaging().sha256Hex(assembled),
+    imaging().sha256Hex(transparentQr),
+    imaging().sha256Hex(cutPng),
+    imaging().sha256Hex(cutSvg),
+    imaging().sha256Hex(pattern.text)
+  ]);
+  const report = {
+    schemaVersion: 8,
+    mode: "assemble",
+    status: qualified ? "generated" : "verification_failed",
+    qualified,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: Date.now() - startedAt,
+    inputs: {
+      poster: {
+        path: poster.path,
+        sha256: poster.sha256,
+        width: poster.width,
+        height: poster.height
+      },
+      qr: {
+        path: qrSource.path,
+        sha256: qrSource.sha256,
+        width: qrSource.width,
+        height: qrSource.height
+      },
+      ...maskInput ? { mask: { path: maskInput.path, sha256: maskInput.sha256 } } : {}
+    },
+    region: {
+      source: regionMask.source,
+      area: regionMask.area,
+      bounds: regionMask.bounds,
+      centroid: regionMask.centroid,
+      ...regionMask.detection ? { detection: regionMask.detection } : {}
+    },
+    qr: {
+      ...qrMetadata,
+      normalizedSize: placement.size,
+      normalizedModulePixels: pitch,
+      overlay: {
+        band: "markers",
+        quietZoneModules: marginModules,
+        markerModules: MARKER_MODULES,
+        crop: {
+          left: QUIET_ZONE_MODULES3 * pitch,
+          top: QUIET_ZONE_MODULES3 * pitch,
+          size: codeGrid.width
+        },
+        x: codeGrid.x,
+        y: codeGrid.y
+      }
+    },
+    placement,
+    pattern: {
+      seed: pattern.seed,
+      alphabet: PATTERN_ALPHABET,
+      textLength: pattern.text.length,
+      textSha256: textSha,
+      ecc: PATTERN_ECC,
+      version: pattern.version,
+      qrModules: pattern.qrModules,
+      quietZoneModules: QUIET_ZONE_MODULES3,
+      totalModules: pattern.totalModules,
+      modulePixels: pitch,
+      pixelStyle,
+      alignment: { alignedToQr: true, phase: { x: phaseX, y: phaseY } },
+      colors: palette,
+      removedTypes: [...REMOVED_TYPES],
+      markerRefill: PATTERN_MARKER_REFILL,
+      refilledModules: pattern.refilledModules,
+      codeSize: pattern.codeSize,
+      canvas: { width, height },
+      crop: pattern.crop
+    },
+    cut: {
+      modulePixels: pitch,
+      lattice: { x: lattice.x, y: lattice.y },
+      radius,
+      safeModules: safeArea.safeModules,
+      droppedPartialModules: safeArea.partialModules,
+      droppedPartialPixels: safeArea.droppedPartialPixels,
+      drawnModules,
+      rim: { modules: rimModulesCount, style: rimRounded ? "rounded-antialiased" : "cell" },
+      regionMarginModules: regionMargin ? 1 : 0,
+      plateCornerModules: plate.cornerModules,
+      keep: "region-mask",
+      edgeBlend: rimRounded ? "antialiased" : "cell-aligned-over-original"
+    },
+    qrPlate: {
+      band: "markers",
+      marginModules,
+      marginPixels,
+      markerModules: MARKER_MODULES,
+      bandCells,
+      box: codeGrid,
+      holeModules: plate.holeModules,
+      cornerModules: plate.cornerModules,
+      cornerTexturePixels
+    },
+    shape: {
+      bounds: safeArea.bounds,
+      area: drawnModules * pitch * pitch,
+      modules: drawnModules,
+      rimModules: rimModuleCount,
+      marginModules: marginModuleCount,
+      textureModules
+    },
+    artifacts: {
+      poster: ARTIFACT_NAMES.poster,
+      posterSha256: posterSha,
+      regionMask: ARTIFACT_NAMES.regionMask,
+      qr: ARTIFACT_NAMES.qr,
+      qrSha256: qrSha,
+      patternCutPng: ARTIFACT_NAMES.patternCutPng,
+      patternCutPngSha256: cutPngSha,
+      patternCutSvg: ARTIFACT_NAMES.patternCutSvg,
+      patternCutSvgSha256: cutSvgSha
+    },
+    verification: { expectedText: decoded.text, checks, qualified, skippedChecks: [...SKIPPED_DECODE_CHECKS] },
+    phoneScan: "untested",
+    warnings
+  };
+  const encoder = new TextEncoder();
+  const artifacts = {
+    "poster.png": assembled,
+    "region-mask.png": regionMaskPng,
+    "qr.png": transparentQr,
+    "pattern-cut.png": cutPng,
+    "pattern-cut.svg": encoder.encode(cutSvg),
+    "report.json": encoder.encode(`${JSON.stringify(report, null, 2)}
+`)
+  };
+  return { report, artifacts };
+}
+async function assembleRotated(layout, options) {
+  const startedAt = Date.now();
+  const { poster, qrSource, maskInput, regionMask, decoded, qrMetadata, placement, normalizedQr } = layout;
+  const { width, height } = poster;
+  const pitch = placement.modulePixels;
+  const regionBounds = regionPixelBounds(regionMask);
+  const frame = qrWorkingFrame(placement, regionBounds);
+  assertFrameHoldsPlacement(frame, placement, width, height);
+  const selection = Uint8Array.from(regionMask.data, (value) => value ? 1 : 0);
+  const workingMask = sampleMaskIntoQrFrame(selection, width, height, frame, placement);
+  const lattice = buildModuleLattice(frame.width, frame.height, pitch, frame.qr);
+  const safeArea = computeSafeArea(workingMask, frame.width, frame.height, lattice);
+  const marginModules = options.qrMargin ?? BAND_MODULES;
+  const marginPixels = marginModules * pitch;
+  const radius = options.radius ?? 2 * pitch;
+  const rimModulesCount = options.rimModules ?? DEFAULT_RIM_MODULES;
+  const rimRounded = options.rimRounded ?? false;
+  const transparentBlank = options.transparentBlank ?? false;
+  const palette = options.palette ?? DEFAULT_PALETTE;
+  const light = hexToRgb(palette.background);
+  if (!Number.isInteger(rimModulesCount) || rimModulesCount < 0 || rimModulesCount > 5)
+    throw new QrPosterError("INVALID_INPUT", "rimModules must be an integer between 0 and 5.");
+  const codeGrid = {
+    x: frame.qr.x + QUIET_ZONE_MODULES3 * pitch,
+    y: frame.qr.y + QUIET_ZONE_MODULES3 * pitch,
+    width: qrMetadata.qrModules * pitch,
+    height: qrMetadata.qrModules * pitch
+  };
+  const { arms, cornerBlocks } = markerBandRects(codeGrid, qrMetadata.qrModules, pitch, marginModules);
+  const plateCornersCut = radius >= PLATE_CORNER_EPSILON;
+  const plate = computePlateModules(
+    lattice,
+    [codeGrid, ...arms, ...plateCornersCut ? [] : cornerBlocks],
+    plateCornersCut ? cornerBlocks : []
+  );
+  const bandCells = plate.holeModules - qrMetadata.qrModules * qrMetadata.qrModules;
+  const drawn = new Uint8Array(lattice.columns * lattice.rows);
+  let drawnModules = 0;
+  for (let index = 0; index < drawn.length; index++) {
+    if (!safeArea.safe[index] || plate.cells[index]) continue;
+    drawn[index] = 1;
+    drawnModules++;
+  }
+  const regionMargin = options.regionMargin ?? false;
+  const { margin, rim } = computeRegionBands(safeArea.safe, lattice, rimModulesCount, regionMargin);
+  const quietZone = computeTightBlockQuietZone(
+    workingMask,
+    frame.width,
+    frame.height,
+    safeArea.safe,
+    plate.cells,
+    lattice,
+    { x: frame.qr.x, y: frame.qr.y, size: placement.size },
+    rimModulesCount === 0
+  );
+  let rimModuleCount = 0;
+  let marginModuleCount = 0;
+  let regionMarginModuleCount = 0;
+  let textureModules = 0;
+  for (let index = 0; index < drawn.length; index++) {
+    if (!drawn[index]) continue;
+    if (margin[index]) regionMarginModuleCount++;
+    if (margin[index] || quietZone.cells[index]) marginModuleCount++;
+    else if (rim[index]) rimModuleCount++;
+    else textureModules++;
+  }
+  if (textureModules === 0 && (rimModulesCount > 0 || regionMargin) && quietZone.modules === 0) {
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      (regionMargin ? `The rotated painted region leaves no texture module once the margin, ${rimModulesCount}-module rim, and ` : `The rotated painted region leaves no texture module once the ${rimModulesCount}-module rim and `) + "the QR plate are removed. Use a larger region, a smaller QR box, or a smaller rotation."
+    );
+  }
+  const pattern = await buildPosterPattern({
+    width: frame.width,
+    height: frame.height,
+    modulePixels: pitch,
+    alignTo: { x: frame.qr.x, y: frame.qr.y },
+    ...options.seed !== void 0 ? { seed: options.seed } : {}
+  });
+  const phaseX = ((pattern.crop.left + frame.qr.x) % pitch + pitch) % pitch;
+  const phaseY = ((pattern.crop.top + frame.qr.y) % pitch + pitch) % pitch;
+  if (phaseX !== 0 || phaseY !== 0) {
+    throw new QrPosterError(
+      "IMAGE_PROCESSING_FAILED",
+      `The texture window at ${pattern.crop.left},${pattern.crop.top} is not phase-locked to the ${pitch}px QR lattice (residual ${phaseX},${phaseY}); whole-module drawing needs both on one grid.`,
+      3
+    );
+  }
+  const moduleOffsetX = (pattern.crop.left + frame.qr.x % pitch) / pitch;
+  const moduleOffsetY = (pattern.crop.top + frame.qr.y % pitch) / pitch;
+  const matrixOffsetX = moduleOffsetX - pattern.marginModules;
+  const matrixOffsetY = moduleOffsetY - pattern.marginModules;
+  const effective = pattern.matrix.map((row) => row.slice());
+  for (let row = 0; row < lattice.rows; row++) {
+    for (let column = 0; column < lattice.columns; column++) {
+      const index = row * lattice.columns + column;
+      if (!drawn[index]) continue;
+      const matrixRow = row + matrixOffsetY;
+      const matrixColumn = column + matrixOffsetX;
+      if (matrixRow < 0 || matrixColumn < 0 || matrixRow >= effective.length || matrixColumn >= effective.length)
+        continue;
+      if (rim[index]) effective[matrixRow][matrixColumn] = true;
+    }
+  }
+  const include = (moduleX, moduleY) => {
+    const column = moduleX - moduleOffsetX;
+    const row = moduleY - moduleOffsetY;
+    if (column < 0 || row < 0 || column >= lattice.columns || row >= lattice.rows) return false;
+    return drawn[row * lattice.columns + column] === 1;
+  };
+  const pixelStyle = options.pixelStyle ?? PATTERN_PIXEL_STYLE;
+  let texturePng = await renderPattern(effective, pitch, pixelStyle, {
+    marginModules: pattern.marginModules,
+    window: { ...pattern.crop, width: frame.width, height: frame.height },
+    include,
+    ink: palette.pixel,
+    light: palette.background
+  });
+  const render = await decodePng(texturePng, "pattern.png", "rendered pattern");
+  const qrRaw = (await decodePng(normalizedQr, "normalized QR", "normalized QR")).data;
+  if (regionMargin) paintRegionMargin(render.data, frame.width, lattice, drawn, margin, qrRaw);
+  if (quietZone.modules > 0) {
+    paintModuleCells(render.data, frame.width, lattice, quietZone.cells, light);
+  }
+  if (regionMargin || quietZone.modules > 0) {
+    texturePng = await rgbaToPng(render.data, frame.width, frame.height);
+  }
+  const unitPath = buildModulePath(drawn, lattice);
+  const coverage = await renderModuleCoverage(unitPath, frame.width, frame.height, rimRounded);
+  const cutLayer = new Uint8Array(frame.width * frame.height * 4);
+  for (let index = 0; index < coverage.length; index++) {
+    const alpha = coverage[index];
+    if (alpha === 0) continue;
+    const offset = index * 4;
+    if (transparentBlank) {
+      const textureAlpha = Math.round(render.data[offset + 3] * alpha / 255);
+      if (textureAlpha === 0) continue;
+      cutLayer[offset] = render.data[offset];
+      cutLayer[offset + 1] = render.data[offset + 1];
+      cutLayer[offset + 2] = render.data[offset + 2];
+      cutLayer[offset + 3] = textureAlpha;
+      continue;
+    }
+    if (alpha === 255 || !rimRounded) {
+      cutLayer[offset] = render.data[offset];
+      cutLayer[offset + 1] = render.data[offset + 1];
+      cutLayer[offset + 2] = render.data[offset + 2];
+      cutLayer[offset + 3] = 255;
+    } else {
+      const srcA = alpha / 255;
+      cutLayer[offset] = Math.round(render.data[offset] * srcA + light[0] * (1 - srcA));
+      cutLayer[offset + 1] = Math.round(render.data[offset + 1] * srcA + light[1] * (1 - srcA));
+      cutLayer[offset + 2] = Math.round(render.data[offset + 2] * srcA + light[2] * (1 - srcA));
+      cutLayer[offset + 3] = alpha;
+    }
+  }
+  const workingCutSvg = buildCutSvg(unitPath, frame.width, frame.height, texturePng);
+  const rotatedCutPng = await rotateBackCutPng(cutLayer, frame, placement, width, height, regionMask);
+  const posterCutSvg = buildRotatedCutSvg(workingCutSvg, placement, frame, width, height);
+  const overlay = new Uint8Array(frame.width * frame.height * 4);
+  for (let row = 0; row < frame.height; row++) {
+    for (let column = 0; column < frame.width; column++) {
+      const index = row * frame.width + column;
+      const offset = index * 4;
+      const cell = moduleCellIndex(lattice, column, row);
+      const plateSource = cell >= 0 && plate.cells[cell] === 1 ? workingQrSourceOffset(frame, column, row) : -1;
+      if (plateSource >= 0) {
+        for (let channel = 0; channel < 4; channel++) overlay[offset + channel] = qrRaw[plateSource + channel];
+        continue;
+      }
+      const alpha = coverage[index];
+      if (alpha === 0) continue;
+      for (let channel = 0; channel < 3; channel++) overlay[offset + channel] = render.data[offset + channel];
+      overlay[offset + 3] = transparentBlank ? Math.round(render.data[offset + 3] * alpha / 255) : alpha === 255 || !rimRounded ? 255 : alpha;
+    }
+  }
+  const output = Uint8Array.from(poster.data);
+  let outsidePassed = true;
+  let qrPassed = true;
+  let plateCornersPassed = true;
+  let moduleCutPassed = true;
+  let alphaPassed = true;
+  let transparentBackgroundPassed = true;
+  let cornerTexturePixels = 0;
+  for (let row = 0; row < height; row++) {
+    for (let column = 0; column < width; column++) {
+      const index = row * width + column;
+      const offset = index * 4;
+      const local = posterToPlatePoint(column + 0.5, row + 0.5, placement);
+      const wx = Math.floor(local.x - frame.left);
+      const wy = Math.floor(local.y - frame.top);
+      const inFrame = wx >= 0 && wy >= 0 && wx < frame.width && wy < frame.height;
+      const cell = inFrame ? moduleCellIndex(lattice, wx, wy) : -1;
+      const isPlate = cell >= 0 && plate.cells[cell] === 1;
+      const isCorner = cell >= 0 && plate.corners[cell] === 1;
+      const isDrawn = cell >= 0 && drawn[cell] === 1;
+      const overlayOffset = inFrame ? (wy * frame.width + wx) * 4 : -1;
+      const srcA = inFrame ? overlay[overlayOffset + 3] / 255 : 0;
+      let changed = false;
+      if (regionMask.data[index] && inFrame) {
+        if (isPlate) {
+          const plateSource = workingQrSourceOffset(frame, wx, wy);
+          for (let channel = 0; channel < 4; channel++) {
+            const value = qrRaw[plateSource + channel];
+            if (value !== poster.data[offset + channel]) changed = true;
+            output[offset + channel] = value;
+          }
+        } else if (srcA > 0 && transparentBlank) {
+          compositePixelOver(overlay, overlayOffset, output, offset);
+          for (let channel = 0; channel < 4; channel++)
+            if (output[offset + channel] !== poster.data[offset + channel]) changed = true;
+        } else if (srcA > 0) {
+          for (let channel = 0; channel < 3; channel++) {
+            const dst = output[offset + channel];
+            const value = srcA === 1 ? overlay[overlayOffset + channel] : Math.round(overlay[overlayOffset + channel] * srcA + dst * (1 - srcA));
+            if (value !== poster.data[offset + channel]) changed = true;
+            output[offset + channel] = value;
+          }
+        }
+      }
+      for (let channel = 0; channel < 4; channel++) {
+        const value = output[offset + channel];
+        if (!regionMask.data[index] && value !== poster.data[offset + channel]) outsidePassed = false;
+        if (isPlate && value !== qrRaw[workingQrSourceOffset(frame, wx, wy) + channel]) qrPassed = false;
+        if (isCorner && value !== overlay[overlayOffset + channel]) plateCornersPassed = false;
+      }
+      const allowed = rimRounded ? srcA > 0 || isPlate : isDrawn || isPlate;
+      if (changed && !allowed) moduleCutPassed = false;
+      if (output[offset + 3] !== poster.data[offset + 3]) alphaPassed = false;
+      if (transparentBlank) {
+        const expectedAlpha = regionMask.data[index] && inFrame ? overlay[overlayOffset + 3] : 0;
+        if (poster.data[offset + 3] !== 0 || output[offset + 3] !== expectedAlpha) transparentBackgroundPassed = false;
+      }
+      if (isCorner) cornerTexturePixels++;
+    }
+  }
+  const assembled = await rgbaToPng(output, width, height);
+  const checks = [
+    {
+      name: "sourceQr",
+      passed: true,
+      decodedText: decoded.text,
+      decoder: decoded.decoder,
+      ...decoded.version !== void 0 ? { version: decoded.version } : {}
+    },
+    await verifyQrVariant("normalizedQr", normalizedQr, decoded.text),
+    { name: "outsideRegionPixels", passed: outsidePassed },
+    { name: "qrPixels", passed: qrPassed },
+    { name: "qrPlateCorners", passed: plateCornersPassed },
+    { name: "moduleCut", passed: moduleCutPassed },
+    ...transparentBlank ? [{ name: "transparentBackground", passed: transparentBackgroundPassed }] : [{ name: "alphaPreserved", passed: alphaPassed }]
+  ];
+  const qualified = checks.every((check) => check.passed);
+  const warnings = [];
+  warnings.push(
+    quietZone.modules > 0 ? `The ${QUIET_ZONE_MODULES3}-module QR quiet margin is kept light in this tight rectangular mask (${quietZone.modules} safe cells); the finder band is ${formatNumber(marginModules)} module deep (${marginPixels}px at ${pitch}px modules). The assembled poster is not decode-verified.` : `The light band is kept beside the three finder markers only: ${bandCells} cell(s) ${formatNumber(marginModules)} module deep (${marginPixels}px at ${pitch}px modules), with the plate's ${plate.cornerModules} corner block module(s) handed back to the texture. The code's other edges sit flush against the texture, so the profile's ${QUIET_ZONE_MODULES3}-module quiet zone is not kept and the assembled poster is not decode-verified; only the QR input and the geometry checks ran.`
+  );
+  if (regionMargin)
+    warnings.push(
+      `A one-module light margin follows the selected region inside its edge (${regionMarginModuleCount} whole modules).`
+    );
+  if (safeArea.partialModules > 0) {
+    warnings.push(
+      `${safeArea.partialModules} module(s) crossed the painted region's edge in the QR's frame and kept the original artwork (${safeArea.droppedPartialPixels} region pixels); the cut draws whole modules only.`
+    );
+  }
+  if (pitch < 6) warnings.push(`The normalized QR uses ${pitch}px modules; 6px or larger is preferred.`);
+  for (const check of checks) {
+    if (!check.passed) warnings.push(`${check.name} verification failed${check.error ? `: ${check.error}` : "."}`);
+  }
+  const regionMaskPng = await renderRegionMask(regionMask);
+  const transparentQr = await transparentQrBackground(normalizedQr, palette);
+  const [posterSha, qrSha, cutPngSha, cutSvgSha, textSha] = await Promise.all([
+    imaging().sha256Hex(assembled),
+    imaging().sha256Hex(transparentQr),
+    imaging().sha256Hex(rotatedCutPng),
+    imaging().sha256Hex(posterCutSvg),
+    imaging().sha256Hex(pattern.text)
+  ]);
+  const report = {
+    schemaVersion: 8,
+    mode: "assemble",
+    status: qualified ? "generated" : "verification_failed",
+    qualified,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: Date.now() - startedAt,
+    inputs: {
+      poster: {
+        path: poster.path,
+        sha256: poster.sha256,
+        width: poster.width,
+        height: poster.height
+      },
+      qr: {
+        path: qrSource.path,
+        sha256: qrSource.sha256,
+        width: qrSource.width,
+        height: qrSource.height
+      },
+      ...maskInput ? { mask: { path: maskInput.path, sha256: maskInput.sha256 } } : {}
+    },
+    region: {
+      source: regionMask.source,
+      area: regionMask.area,
+      bounds: regionMask.bounds,
+      centroid: regionMask.centroid,
+      ...regionMask.detection ? { detection: regionMask.detection } : {}
+    },
+    qr: {
+      ...qrMetadata,
+      normalizedSize: placement.size,
+      normalizedModulePixels: pitch,
+      overlay: {
+        band: "markers",
+        quietZoneModules: marginModules,
+        markerModules: MARKER_MODULES,
+        crop: {
+          left: QUIET_ZONE_MODULES3 * pitch,
+          top: QUIET_ZONE_MODULES3 * pitch,
+          size: codeGrid.width
+        },
+        x: codeGrid.x,
+        y: codeGrid.y
+      }
+    },
+    placement,
+    pattern: {
+      seed: pattern.seed,
+      alphabet: PATTERN_ALPHABET,
+      textLength: pattern.text.length,
+      textSha256: textSha,
+      ecc: PATTERN_ECC,
+      version: pattern.version,
+      qrModules: pattern.qrModules,
+      quietZoneModules: QUIET_ZONE_MODULES3,
+      totalModules: pattern.totalModules,
+      modulePixels: pitch,
+      pixelStyle,
+      alignment: { alignedToQr: true, phase: { x: phaseX, y: phaseY } },
+      colors: palette,
+      removedTypes: [...REMOVED_TYPES],
+      markerRefill: PATTERN_MARKER_REFILL,
+      refilledModules: pattern.refilledModules,
+      codeSize: pattern.codeSize,
+      canvas: { width: frame.width, height: frame.height },
+      crop: pattern.crop
+    },
+    cut: {
+      modulePixels: pitch,
+      lattice: { x: lattice.x, y: lattice.y },
+      radius,
+      safeModules: safeArea.safeModules,
+      droppedPartialModules: safeArea.partialModules,
+      droppedPartialPixels: safeArea.droppedPartialPixels,
+      drawnModules,
+      rim: { modules: rimModulesCount, style: rimRounded ? "rounded-antialiased" : "cell" },
+      regionMarginModules: regionMargin ? 1 : 0,
+      plateCornerModules: plate.cornerModules,
+      keep: "region-mask",
+      edgeBlend: rimRounded ? "antialiased" : "cell-aligned-over-original"
+    },
+    qrPlate: {
+      band: "markers",
+      marginModules,
+      marginPixels,
+      markerModules: MARKER_MODULES,
+      bandCells,
+      box: codeGrid,
+      holeModules: plate.holeModules,
+      cornerModules: plate.cornerModules,
+      cornerTexturePixels
+    },
+    shape: {
+      bounds: safeArea.bounds,
+      area: drawnModules * pitch * pitch,
+      modules: drawnModules,
+      rimModules: rimModuleCount,
+      marginModules: marginModuleCount,
+      textureModules
+    },
+    artifacts: {
+      poster: ARTIFACT_NAMES.poster,
+      posterSha256: posterSha,
+      regionMask: ARTIFACT_NAMES.regionMask,
+      qr: ARTIFACT_NAMES.qr,
+      qrSha256: qrSha,
+      patternCutPng: ARTIFACT_NAMES.patternCutPng,
+      patternCutPngSha256: cutPngSha,
+      patternCutSvg: ARTIFACT_NAMES.patternCutSvg,
+      patternCutSvgSha256: cutSvgSha
+    },
+    verification: { expectedText: decoded.text, checks, qualified, skippedChecks: [...SKIPPED_DECODE_CHECKS] },
+    phoneScan: "untested",
+    warnings
+  };
+  const encoder = new TextEncoder();
+  const artifacts = {
+    "poster.png": assembled,
+    "region-mask.png": regionMaskPng,
+    "qr.png": transparentQr,
+    "pattern-cut.png": rotatedCutPng,
+    "pattern-cut.svg": encoder.encode(posterCutSvg),
+    "report.json": encoder.encode(`${JSON.stringify(report, null, 2)}
+`)
+  };
+  return { report, artifacts };
+}
+function workingQrSourceOffset(frame, workingX, workingY) {
+  return ((workingY - frame.qr.y) * frame.qr.size + (workingX - frame.qr.x)) * 4;
+}
+function buildRotatedCutSvg(workingCutSvg, placement, frame, posterWidth, posterHeight) {
+  const body = workingCutSvg.replace(/^<svg[^>]*>/, "").replace(/<\/svg>\s*$/, "");
+  const centerX = placement.x + placement.size / 2;
+  const centerY = placement.y + placement.size / 2;
+  const transform = `translate(${centerX},${centerY}) rotate(${placement.rotation}) translate(${frame.left - centerX},${frame.top - centerY})`;
+  const header = `<svg xmlns="http://www.w3.org/2000/svg" width="${posterWidth}" height="${posterHeight}" viewBox="0 0 ${posterWidth} ${posterHeight}">`;
+  return `${header}
+  <g transform="${transform}">${body}</g>
+</svg>
+`;
+}
+async function rotateBackCutPng(cutLayer, frame, placement, posterWidth, posterHeight, regionMask) {
+  const output = new Uint8Array(posterWidth * posterHeight * 4);
+  for (let row = 0; row < posterHeight; row++) {
+    for (let column = 0; column < posterWidth; column++) {
+      if (!regionMask.data[row * regionMask.width + column]) continue;
+      const local = posterToPlatePoint(column + 0.5, row + 0.5, placement);
+      const wx = Math.floor(local.x - frame.left);
+      const wy = Math.floor(local.y - frame.top);
+      if (wx < 0 || wy < 0 || wx >= frame.width || wy >= frame.height) continue;
+      const offset = (wy * frame.width + wx) * 4;
+      if (cutLayer[offset + 3] === 0) continue;
+      const outOffset = (row * posterWidth + column) * 4;
+      for (let channel = 0; channel < 4; channel++) output[outOffset + channel] = cutLayer[offset + channel];
+    }
+  }
+  return rgbaToPng(output, posterWidth, posterHeight);
+}
+function paintRegionMargin(pixels, width, lattice, drawn, margin, markerBackground) {
+  const pitch = lattice.modulePixels;
+  for (let index = 0; index < margin.length; index++) {
+    if (!margin[index] || !drawn[index]) continue;
+    const row = Math.floor(index / lattice.columns);
+    const column = index - row * lattice.columns;
+    const left = lattice.x + column * pitch;
+    const top = lattice.y + row * pitch;
+    for (let y = top; y < top + pitch; y++) {
+      for (let x = left; x < left + pitch; x++) {
+        const offset = (y * width + x) * 4;
+        for (let channel = 0; channel < 4; channel++) pixels[offset + channel] = markerBackground[channel];
+      }
+    }
+  }
+}
+function paintModuleCells(pixels, width, lattice, cells, background) {
+  const pitch = lattice.modulePixels;
+  for (let index = 0; index < cells.length; index++) {
+    if (!cells[index]) continue;
+    const row = Math.floor(index / lattice.columns);
+    const column = index - row * lattice.columns;
+    const left = lattice.x + column * pitch;
+    const top = lattice.y + row * pitch;
+    for (let y = top; y < top + pitch; y++) {
+      for (let x = left; x < left + pitch; x++) {
+        const offset = (y * width + x) * 4;
+        pixels[offset] = background[0];
+        pixels[offset + 1] = background[1];
+        pixels[offset + 2] = background[2];
+        pixels[offset + 3] = 255;
+      }
+    }
+  }
+}
+function markerBandRects(codeGrid, qrModules, pitch, marginModules) {
+  const marginPixels = marginModules * pitch;
+  const markerPixels = MARKER_MODULES * pitch;
+  const last = qrModules - MARKER_MODULES;
+  const origins = [
+    { column: 0, row: 0 },
+    { column: last, row: 0 },
+    { column: 0, row: last }
+  ];
+  const arms = [];
+  const cornerBlocks = [];
+  for (const { column, row } of origins) {
+    const markerX = codeGrid.x + column * pitch;
+    const markerY = codeGrid.y + row * pitch;
+    const outerX = column === 0 ? codeGrid.x - marginPixels : codeGrid.x + codeGrid.width;
+    const outerY = row === 0 ? codeGrid.y - marginPixels : codeGrid.y + codeGrid.height;
+    arms.push({ x: markerX, y: outerY, width: markerPixels, height: marginPixels });
+    arms.push({ x: outerX, y: markerY, width: marginPixels, height: markerPixels });
+    cornerBlocks.push({ x: outerX, y: outerY, width: marginPixels, height: marginPixels });
+  }
+  return { arms, cornerBlocks };
+}
+function qrSourceOffset(placement, column, row) {
+  return ((row - placement.y) * placement.size + column - placement.x) * 4;
+}
+function formatNumber(value) {
+  return String(Math.round(value * 100) / 100);
+}
+
+// src/core/export-sizes.ts
+function bytesToBase642(bytes) {
+  let binary = "";
+  for (let start = 0; start < bytes.length; start += 32768)
+    binary += String.fromCharCode(...bytes.subarray(start, start + 32768));
+  return btoa(binary);
+}
+function buildPosterSvg(png, width, height) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <image x="0" y="0" width="${width}" height="${height}" preserveAspectRatio="none" href="data:image/png;base64,${bytesToBase642(png)}"/>
+</svg>
+`;
+}
+
+// src/core/mask.ts
+var STRONG_BLACK_THRESHOLD = 32;
+var TOLERANT_LUMA_THRESHOLD = 96;
+var DENSITY_THRESHOLD = 0.8;
+var MIN_COMPONENT_FRACTION = 0.01;
+function isSelectedMaskPixel(r, g, b, alpha) {
+  return alpha >= 128 && luma(r, g, b) >= 128;
+}
+function buildManualRegionMask(mask, width, height) {
+  if (mask.width !== width || mask.height !== height) {
+    throw new QrPosterError(
+      "MASK_INVALID",
+      `Mask dimensions ${mask.width}x${mask.height} do not match poster dimensions ${width}x${height}.`
+    );
+  }
+  const selected = new Uint8Array(width * height);
+  for (let index = 0; index < selected.length; index++) {
+    const offset = index * 4;
+    selected[index] = isSelectedMaskPixel(
+      mask.data[offset],
+      mask.data[offset + 1],
+      mask.data[offset + 2],
+      mask.data[offset + 3]
+    ) ? 255 : 0;
+  }
+  const stats = calculateMaskStats(selected, width, height);
+  if (stats.area === 0)
+    throw new QrPosterError("MASK_INVALID", "The supplied mask does not contain any selected white pixels.");
+  return { data: selected, width, height, source: "file", ...stats };
+}
+function detectRegionMask(image) {
+  const { data, width, height } = image;
+  const pixelCount = width * height;
+  const radius = clamp(Math.round(Math.min(width, height) / 120), 2, 16);
+  const strong = new Uint8Array(pixelCount);
+  const tolerant = new Uint8Array(pixelCount);
+  for (let index = 0; index < pixelCount; index++) {
+    const offset = index * 4;
+    const r = data[offset];
+    const g = data[offset + 1];
+    const b = data[offset + 2];
+    const alpha = data[offset + 3];
+    if (alpha >= 128 && r <= STRONG_BLACK_THRESHOLD && g <= STRONG_BLACK_THRESHOLD && b <= STRONG_BLACK_THRESHOLD)
+      strong[index] = 1;
+    if (alpha >= 128 && luma(r, g, b) <= TOLERANT_LUMA_THRESHOLD) tolerant[index] = 1;
+  }
+  const integral = buildIntegral(strong, width, height);
+  const core = new Uint8Array(pixelCount);
+  for (let y = 0; y < height; y++) {
+    const y0 = Math.max(0, y - radius);
+    const y1 = Math.min(height - 1, y + radius);
+    for (let x = 0; x < width; x++) {
+      const index = y * width + x;
+      if (!strong[index]) continue;
+      const x0 = Math.max(0, x - radius);
+      const x1 = Math.min(width - 1, x + radius);
+      const blackCount = integralSum(integral, width + 1, x0, y0, x1 + 1, y1 + 1);
+      const windowArea = (x1 - x0 + 1) * (y1 - y0 + 1);
+      if (blackCount / windowArea >= DENSITY_THRESHOLD) core[index] = 1;
+    }
+  }
+  const { labels, components } = labelComponents(core, width, height);
+  const minimumArea = Math.ceil(pixelCount * MIN_COMPONENT_FRACTION);
+  const candidates = components.filter((component) => component.intersectsCenter && component.area >= minimumArea).sort((a, b) => {
+    if (b.area !== a.area) return b.area - a.area;
+    return centerDistance(a, width, height) - centerDistance(b, width, height);
+  });
+  if (candidates.length === 0) {
+    throw new QrPosterError(
+      "MASK_AMBIGUOUS",
+      "Could not confidently find a dense painted region near the poster center. Supply --mask with a white selected region."
+    );
+  }
+  const winner = candidates[0];
+  const runnerUp = candidates[1];
+  const dominanceRatio = runnerUp ? winner.area / runnerUp.area : null;
+  if (runnerUp && runnerUp.area >= winner.area * 0.25) {
+    throw new QrPosterError(
+      "MASK_AMBIGUOUS",
+      `Two central painted-region candidates are too similar (${winner.area} and ${runnerUp.area} pixels). Supply --mask.`
+    );
+  }
+  if (winner.touchesOuterBand) {
+    throw new QrPosterError(
+      "MASK_AMBIGUOUS",
+      "The detected painted region reaches the outer 2% of the image. Supply --mask to avoid consuming the poster background."
+    );
+  }
+  let grown = new Uint8Array(pixelCount);
+  for (let index = 0; index < pixelCount; index++) {
+    if (labels[index] === winner.label) grown[index] = 1;
+  }
+  for (let step = 0; step < radius + 1; step++) {
+    const next = grown.slice();
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const index = y * width + x;
+        if (grown[index] || !tolerant[index]) continue;
+        if (hasSelectedNeighbour(grown, width, height, x, y)) next[index] = 1;
+      }
+    }
+    grown = next;
+  }
+  const selected = new Uint8Array(pixelCount);
+  for (let index = 0; index < pixelCount; index++) selected[index] = grown[index] ? 255 : 0;
+  const stats = calculateMaskStats(selected, width, height);
+  return {
+    data: selected,
+    width,
+    height,
+    source: "auto",
+    ...stats,
+    detection: {
+      strongBlackThreshold: STRONG_BLACK_THRESHOLD,
+      tolerantLumaThreshold: TOLERANT_LUMA_THRESHOLD,
+      separationRadius: radius,
+      densityThreshold: DENSITY_THRESHOLD,
+      candidateAreas: candidates.map((candidate) => candidate.area),
+      dominanceRatio
+    }
+  };
+}
+function calculateMaskStats(data, width, height) {
+  let area = 0;
+  let sumX = 0;
+  let sumY = 0;
+  let minX = width;
+  let minY = height;
+  let maxX = -1;
+  let maxY = -1;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      if (!data[y * width + x]) continue;
+      area++;
+      sumX += x;
+      sumY += y;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  if (area === 0) throw new QrPosterError("MASK_INVALID", "The region mask is empty.");
+  return {
+    area,
+    bounds: { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 },
+    centroid: { x: sumX / area, y: sumY / area }
+  };
+}
+function buildIntegral(data, width, height) {
+  const stride = width + 1;
+  const integral = new Uint32Array(stride * (height + 1));
+  for (let y = 1; y <= height; y++) {
+    let rowSum = 0;
+    for (let x = 1; x <= width; x++) {
+      rowSum += data[(y - 1) * width + x - 1];
+      integral[y * stride + x] = integral[(y - 1) * stride + x] + rowSum;
+    }
+  }
+  return integral;
+}
+function integralSum(data, stride, x0, y0, x1, y1) {
+  return data[y1 * stride + x1] - data[y0 * stride + x1] - data[y1 * stride + x0] + data[y0 * stride + x0];
+}
+function labelComponents(core, width, height) {
+  const labels = new Int32Array(core.length);
+  const queue = new Int32Array(core.length);
+  const components = [];
+  const centerMinX = width * 0.15;
+  const centerMaxX = width * 0.85;
+  const centerMinY = height * 0.15;
+  const centerMaxY = height * 0.85;
+  const outerX = width * 0.02;
+  const outerY = height * 0.02;
+  let label = 0;
+  for (let start = 0; start < core.length; start++) {
+    if (!core[start] || labels[start]) continue;
+    label++;
+    let head = 0;
+    let tail = 1;
+    queue[0] = start;
+    labels[start] = label;
+    const component = {
+      label,
+      area: 0,
+      sumX: 0,
+      sumY: 0,
+      intersectsCenter: false,
+      touchesOuterBand: false
+    };
+    while (head < tail) {
+      const index = queue[head++];
+      const x = index % width;
+      const y = Math.floor(index / width);
+      component.area++;
+      component.sumX += x;
+      component.sumY += y;
+      if (x >= centerMinX && x <= centerMaxX && y >= centerMinY && y <= centerMaxY) component.intersectsCenter = true;
+      if (x < outerX || x >= width - outerX || y < outerY || y >= height - outerY) component.touchesOuterBand = true;
+      for (let dy = -1; dy <= 1; dy++) {
+        const ny = y + dy;
+        if (ny < 0 || ny >= height) continue;
+        for (let dx = -1; dx <= 1; dx++) {
+          if (dx === 0 && dy === 0) continue;
+          const nx = x + dx;
+          if (nx < 0 || nx >= width) continue;
+          const neighbour = ny * width + nx;
+          if (core[neighbour] && !labels[neighbour]) {
+            labels[neighbour] = label;
+            queue[tail++] = neighbour;
+          }
+        }
+      }
+    }
+    components.push(component);
+  }
+  return { labels, components };
+}
+function hasSelectedNeighbour(data, width, height, x, y) {
+  for (let dy = -1; dy <= 1; dy++) {
+    const ny = y + dy;
+    if (ny < 0 || ny >= height) continue;
+    for (let dx = -1; dx <= 1; dx++) {
+      if (dx === 0 && dy === 0) continue;
+      const nx = x + dx;
+      if (nx >= 0 && nx < width && data[ny * width + nx]) return true;
+    }
+  }
+  return false;
+}
+function centerDistance(component, width, height) {
+  const x = component.sumX / component.area;
+  const y = component.sumY / component.area;
+  return Math.hypot(x - width / 2, y - height / 2);
+}
+function clamp(value, minimum, maximum) {
+  return Math.max(minimum, Math.min(maximum, value));
+}
+
+// src/schema.ts
+import { z } from "zod";
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var MAX_PIXELS = 4e6;
+var MAX_BODY_BYTES = 2 * MAX_IMAGE_BYTES + 64 * 1024;
+var contentSchema = z.string().max(8e3, "Text exceeds QR capacity.").refine((s) => s.trim().length > 0, "Enter text or a URL.").refine((s) => !/[\r\n]/.test(s), "Use one line only.");
+var rotationSchema = z.number().finite().default(0);
+var placementSchema = z.object({
+  x: z.number().int(),
+  y: z.number().int(),
+  size: z.number().int().positive(),
+  rotation: rotationSchema
+}).strict();
+var settingsSchema = z.object({
+  seed: z.number().int().min(0).max(4294967295),
+  qrMargin: z.literal(1).default(1),
+  plateCorners: z.enum(["texture", "light"]).default("texture"),
+  regionMargin: z.boolean().default(false),
+  rimModules: z.number().int().min(0).max(5).default(1),
+  rimRounded: z.boolean().default(false),
+  ecc: z.enum(["L", "M", "Q", "H"]).default("M"),
+  pixelStyle: z.enum(["square", "rounded", "dot"]).default("dot"),
+  finderMarkers: z.object({
+    tl: z.object({
+      style: z.enum(["square", "rounded"]).default("rounded"),
+      shape: z.enum(["square", "circle", "octagon", "squircle"]).default("circle"),
+      inner: z.enum(["square", "circle", "plus", "diamond", "squircle"]).default("circle")
+    }).default({ style: "rounded", shape: "circle", inner: "circle" }),
+    tr: z.object({
+      style: z.enum(["square", "rounded"]).default("rounded"),
+      shape: z.enum(["square", "circle", "octagon", "squircle"]).default("circle"),
+      inner: z.enum(["square", "circle", "plus", "diamond", "squircle"]).default("circle")
+    }).default({ style: "rounded", shape: "circle", inner: "circle" }),
+    bl: z.object({
+      style: z.enum(["square", "rounded"]).default("rounded"),
+      shape: z.enum(["square", "circle", "octagon", "squircle"]).default("circle"),
+      inner: z.enum(["square", "circle", "plus", "diamond", "squircle"]).default("circle")
+    }).default({ style: "rounded", shape: "circle", inner: "circle" })
+  }).default({
+    tl: { style: "rounded", shape: "circle", inner: "circle" },
+    tr: { style: "rounded", shape: "circle", inner: "circle" },
+    bl: { style: "rounded", shape: "circle", inner: "circle" }
+  }),
+  markerSub: z.enum(["square", "circle"]).default("square"),
+  colors: z.object({
+    pixel: z.string().regex(HEX_PATTERN),
+    marker: z.string().regex(HEX_PATTERN),
+    background: z.string().regex(HEX_PATTERN)
+  }).default(DEFAULT_PALETTE)
+}).strict();
+var requestSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  content: contentSchema,
+  placement: placementSchema.optional(),
+  previousTotalModules: z.number().int().min(25).max(181).optional(),
+  settings: settingsSchema
+}).strict();
+function recenterPlacement(box, previousModules, nextModules) {
+  const size = Math.max(4, Math.round(box.size / previousModules)) * nextModules;
+  const offset = (box.size - size) / 2;
+  return {
+    x: Math.round(box.x + offset),
+    y: Math.round(box.y + offset),
+    size,
+    rotation: canonicalizeRotation(box.rotation)
+  };
+}
+function fitsMask(mask, width, height, box) {
+  if (![box.x, box.y, box.size].every(Number.isInteger) || box.size <= 0 || box.x < 0 || box.y < 0 || box.x + box.size > width || box.y + box.size > height)
+    return false;
+  const size = box.size;
+  const rotation = canonicalizeRotation(box.rotation);
+  if (rotation === 0) {
+    for (let y = box.y; y < box.y + size; y++)
+      for (let x = box.x; x < box.x + size; x++) if (!mask[y * width + x]) return false;
+    return true;
+  }
+  const footprint = rotatedFootprintBounds({ x: box.x, y: box.y, size, rotation }, width, height);
+  const placementBox = { x: box.x, y: box.y, size, rotation };
+  for (let y = footprint.top; y < footprint.bottom; y++) {
+    for (let x = footprint.left; x < footprint.right; x++) {
+      const local = posterToPlatePoint(x + 0.5, y + 0.5, placementBox);
+      if (!localPointInPlate(local.x, local.y, size)) continue;
+      if (!mask[y * width + x]) return false;
+    }
+  }
+  return true;
+}
+
+// src/core/placement.ts
+var MINIMUM_MODULE_PIXELS = 4;
+var REGION_TOO_SMALL_MESSAGE = `The painted region cannot fit the QR code at the minimum ${MINIMUM_MODULE_PIXELS}px module size. Supply a larger region or QR position.`;
+function placeQr(mask, totalModules, requested) {
+  if (requested) return validateManualPlacement(mask, totalModules, requested);
+  const largestSquare = findLargestSquareSize(mask.data, mask.width, mask.height);
+  const modulePixels = Math.floor(largestSquare / totalModules);
+  if (modulePixels < MINIMUM_MODULE_PIXELS) {
+    throw new QrPosterError("QR_LAYOUT_INVALID", REGION_TOO_SMALL_MESSAGE);
+  }
+  const size = totalModules * modulePixels;
+  const topLeft = findClosestSquare(mask, size);
+  return {
+    x: topLeft.x,
+    y: topLeft.y,
+    size,
+    rotation: 0,
+    modulePixels,
+    totalModules,
+    mode: "auto",
+    artPaddingModules: 0
+  };
+}
+function boxIsInsideMask(mask, x, y, size, rotation = 0) {
+  return fitsMask(mask.data, mask.width, mask.height, { x, y, size, rotation });
+}
+function validateManualPlacement(mask, totalModules, box) {
+  const { x, y, size } = box;
+  const rotation = canonicalizeRotation(box.rotation);
+  if (![x, y, size].every(Number.isInteger) || x < 0 || y < 0 || size <= 0)
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      "QR position must contain non-negative integer x,y coordinates and a positive integer size."
+    );
+  if (size % totalModules !== 0)
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      `Manual QR size ${size} must be divisible by ${totalModules} total modules.`
+    );
+  const modulePixels = size / totalModules;
+  if (modulePixels < MINIMUM_MODULE_PIXELS)
+    throw new QrPosterError("QR_LAYOUT_INVALID", `Manual QR module size must be at least ${MINIMUM_MODULE_PIXELS}px.`);
+  if (!boxIsInsideMask(mask, x, y, size, rotation))
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      "The requested QR position is not completely inside the painted region."
+    );
+  return { x, y, size, rotation, modulePixels, totalModules, mode: "manual", artPaddingModules: 0 };
+}
+function findLargestSquareSize(data, width, height) {
+  let previous = new Uint32Array(width + 1);
+  let maximum = 0;
+  for (let y = 1; y <= height; y++) {
+    const current = new Uint32Array(width + 1);
+    for (let x = 1; x <= width; x++) {
+      if (!data[(y - 1) * width + x - 1]) continue;
+      current[x] = 1 + Math.min(previous[x], current[x - 1], previous[x - 1]);
+      maximum = Math.max(maximum, current[x]);
+    }
+    previous = current;
+  }
+  return maximum;
+}
+function findClosestSquare(mask, size) {
+  let previous = new Uint32Array(mask.width + 1);
+  let best;
+  for (let y = 1; y <= mask.height; y++) {
+    const current = new Uint32Array(mask.width + 1);
+    for (let x = 1; x <= mask.width; x++) {
+      if (!mask.data[(y - 1) * mask.width + x - 1]) continue;
+      current[x] = 1 + Math.min(previous[x], current[x - 1], previous[x - 1]);
+      if (current[x] < size) continue;
+      const left = x - size;
+      const top = y - size;
+      const distance = Math.hypot(left + size / 2 - mask.centroid.x, top + size / 2 - mask.centroid.y);
+      if (!best || distance < best.distance) best = { x: left, y: top, distance };
+    }
+    previous = current;
+  }
+  if (!best) throw new QrPosterError("QR_LAYOUT_INVALID", "Could not place the QR code inside the painted region.");
+  return { x: best.x, y: best.y };
+}
+
+// src/png-guard.ts
+var PNG_SIGNATURE = Uint8Array.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var TYPE_IHDR = Uint8Array.from([73, 72, 68, 82]);
+var TYPE_ACTL = Uint8Array.from([97, 99, 84, 76]);
+var PngGuardError = class extends Error {
+  code;
+  field;
+  constructor(code, message, field) {
+    super(message);
+    this.name = "PngGuardError";
+    this.code = code;
+    this.field = field;
+  }
+};
+function matches(bytes, offset, expected) {
+  for (let index = 0; index < expected.length; index++) if (bytes[offset + index] !== expected[index]) return false;
+  return true;
+}
+function parsePngHeader(bytes, field) {
+  if (bytes.length > MAX_IMAGE_BYTES)
+    throw new PngGuardError("UPLOAD_LIMIT", "Each PNG must be 10 MiB or smaller.", field);
+  if (bytes.length < 33 || !matches(bytes, 0, PNG_SIGNATURE))
+    throw new PngGuardError("PNG_INVALID", "Choose a valid PNG image.", field);
+  if (!matches(bytes, 12, TYPE_IHDR)) throw new PngGuardError("PNG_INVALID", "Choose a valid PNG image.", field);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const width = view.getUint32(16);
+  const height = view.getUint32(20);
+  if (width === 0 || height === 0) throw new PngGuardError("PNG_INVALID", "Choose a valid PNG image.", field);
+  if (width * height > MAX_PIXELS)
+    throw new PngGuardError("PNG_INVALID", `Use a single-frame PNG with at most ${MAX_PIXELS / 1e6} megapixels.`, field);
+  let offset = 8;
+  while (offset + 8 <= bytes.length) {
+    const length = view.getUint32(offset);
+    if (offset + 12 + length > bytes.length) break;
+    if (matches(bytes, offset + 4, TYPE_ACTL))
+      throw new PngGuardError(
+        "PNG_INVALID",
+        `Use a single-frame PNG with at most ${MAX_PIXELS / 1e6} megapixels.`,
+        field
+      );
+    offset += 12 + length;
+  }
+  return { width, height };
+}
+
+// src/engine/pipeline.ts
+function bytesToBlob(name, bytes) {
+  const type = name.endsWith(".svg") ? "image/svg+xml" : name.endsWith(".json") ? "application/json" : "image/png";
+  return new Blob([new Uint8Array(bytes)], { type });
+}
+var engineDefaults = {
+  seed: 0,
+  qrMargin: 1,
+  plateCorners: "texture",
+  regionMargin: false,
+  rimModules: 1,
+  rimRounded: false,
+  ecc: "M",
+  pixelStyle: "dot",
+  finderMarkers: {
+    tl: { style: "rounded", shape: "circle", inner: "circle" },
+    tr: { style: "rounded", shape: "circle", inner: "circle" },
+    bl: { style: "rounded", shape: "circle", inner: "circle" }
+  },
+  markerSub: "square",
+  colors: { ...DEFAULT_PALETTE }
+};
+async function readImage(imaging2, bytes, name) {
+  parsePngHeader(bytes, name);
+  try {
+    return await decodePng(bytes, `${name}.png`, name);
+  } catch {
+    throw new QrPosterError("INVALID_INPUT", `Use a single-frame PNG with at most ${4e6 / 1e6} megapixels.`);
+  }
+}
+function validatePlacement({
+  regionMask,
+  qrMetadata,
+  placement,
+  settings
+}) {
+  const p = placeQr(regionMask, qrMetadata.totalModules, placement);
+  const pitch = p.modulePixels;
+  const rotated = p.rotation !== 0;
+  const frame = rotated ? qrWorkingFrame(p, regionPixelBounds(regionMask)) : void 0;
+  const canvasWidth = frame?.width ?? regionMask.width;
+  const canvasHeight = frame?.height ?? regionMask.height;
+  if (frame) assertFrameHoldsPlacement(frame, p, regionMask.width, regionMask.height);
+  const origin = frame?.qr ?? { x: p.x, y: p.y };
+  const mask = frame ? sampleMaskIntoQrFrame(regionMask.data, regionMask.width, regionMask.height, frame, p) : regionMask.data;
+  selectPatternVersion(pitch, canvasWidth, canvasHeight, pitch);
+  const lattice = buildModuleLattice(canvasWidth, canvasHeight, pitch, origin);
+  const safe = computeSafeArea(mask, canvasWidth, canvasHeight, lattice);
+  const { margin, rim } = computeRegionBands(safe.safe, lattice, settings.rimModules, settings.regionMargin);
+  const grid = {
+    x: origin.x + 2 * pitch,
+    y: origin.y + 2 * pitch,
+    width: qrMetadata.qrModules * pitch,
+    height: qrMetadata.qrModules * pitch
+  };
+  const { arms, cornerBlocks } = markerBandRects(grid, qrMetadata.qrModules, pitch, settings.qrMargin);
+  const corners = settings.plateCorners === "texture";
+  const plate = computePlateModules(
+    lattice,
+    [grid, ...arms, ...corners ? [] : cornerBlocks],
+    corners ? cornerBlocks : []
+  );
+  const quietZone = computeTightBlockQuietZone(
+    mask,
+    canvasWidth,
+    canvasHeight,
+    safe.safe,
+    plate.cells,
+    lattice,
+    { x: origin.x, y: origin.y, size: p.size },
+    settings.rimModules === 0
+  );
+  const hasDecorativeTexture = safe.safe.some(
+    (cell, i) => cell && !margin[i] && !rim[i] && !plate.cells[i] && !quietZone.cells[i]
+  );
+  if (!hasDecorativeTexture && quietZone.modules === 0)
+    throw new QrPosterError(
+      "QR_LAYOUT_INVALID",
+      "No decorative texture fits beside this QR. Reduce its size or choose a larger region."
+    );
+  return p;
+}
+async function prepareSource(imaging2, posterBytes, maskBytes) {
+  const poster = await readImage(imaging2, posterBytes, "poster");
+  const maskInput = maskBytes ? await readImage(imaging2, maskBytes, "mask") : void 0;
+  const regionMask = maskInput ? buildManualRegionMask(maskInput, poster.width, poster.height) : detectRegionMask(poster);
+  return {
+    poster,
+    ...maskInput ? { maskInput } : {},
+    regionMask
+  };
+}
+async function resolveQr(imaging2, input) {
+  contentSchema.parse(input.content);
+  const settings = { ...engineDefaults, ...input.settings };
+  const palette = { ...engineDefaults.colors, ...settings.colors };
+  const guard = paletteGuard(palette);
+  if (!guard.ok)
+    throw new QrPosterError(
+      "COLOR_INVALID",
+      `Invalid pattern colors: ${guard.issues.map((issue) => issue.message).join(" ")}`
+    );
+  const generated = await generateQrFromContent(
+    input.content,
+    settings.ecc,
+    settings.pixelStyle,
+    void 0,
+    void 0,
+    void 0,
+    settings.markerSub,
+    settings.finderMarkers,
+    palette
+  );
+  const qrSource = generated.image;
+  const decoded = {
+    ...decodeQrRawDetailed(qrSource.data, qrSource.width, qrSource.height),
+    version: generated.version
+  };
+  if (decoded.text !== input.content)
+    throw new QrPosterError("QR_TEXT_MISMATCH", "Generated QR did not preserve the entered text.");
+  const qrMetadata = inspectQrSource(qrSource, input.content, generated.version);
+  return { qrSource, decoded, qrMetadata };
+}
+function applyPlacement({
+  source,
+  qr,
+  input,
+  settings,
+  unchecked = false
+}) {
+  const { regionMask } = source;
+  const qrMetadata = qr.qrMetadata;
+  const initialPlacement = suggestPlacement(regionMask, qrMetadata.totalModules);
+  const previous = input.placement;
+  let requested = previous;
+  if (previous && input.previousTotalModules && input.previousTotalModules !== qrMetadata.totalModules) {
+    requested = recenterPlacement(previous, input.previousTotalModules, qrMetadata.totalModules);
+  }
+  let validation = null;
+  let placement;
+  if (requested && unchecked) {
+    placement = requested;
+  } else if (requested) {
+    try {
+      placement = validatePlacement({ regionMask, qrMetadata, placement: requested, settings });
+    } catch (e) {
+      validation = e instanceof Error ? e.message : "Invalid placement.";
+      placement = {
+        ...requested,
+        modulePixels: requested.size / qrMetadata.totalModules,
+        totalModules: qrMetadata.totalModules,
+        mode: "manual",
+        artPaddingModules: 0
+      };
+    }
+  } else if (unchecked) {
+    placement = {
+      ...initialPlacement,
+      modulePixels: initialPlacement.size / qrMetadata.totalModules,
+      totalModules: qrMetadata.totalModules,
+      mode: "auto",
+      artPaddingModules: 0
+    };
+  } else {
+    const largest = placeQr(regionMask, qrMetadata.totalModules);
+    for (let pitch = largest.modulePixels; pitch >= 4; pitch--) {
+      try {
+        const size = qrMetadata.totalModules * pitch;
+        const point = findClosestSquare(regionMask, size);
+        placement = validatePlacement({ regionMask, qrMetadata, placement: { ...point, size, rotation: 0 }, settings });
+        placement.mode = "auto";
+        break;
+      } catch (e) {
+        if (!(e instanceof QrPosterError)) throw e;
+      }
+    }
+    if (!placement)
+      throw new QrPosterError(
+        "QR_LAYOUT_INVALID",
+        "This region cannot fit the QR and decorative texture. Use shorter text or a larger black region."
+      );
+    placement.rotation = 0;
+  }
+  const bestPlacement = findBestInsetPlacement(regionMask, qrMetadata.totalModules, placement);
+  const normalizedQr = validation ? qr.qrSource.file : void 0;
+  return {
+    layout: {
+      poster: source.poster,
+      qrSource: qr.qrSource,
+      qrImage: qr.qrSource,
+      ...source.maskInput ? { maskInput: source.maskInput } : {},
+      regionMask,
+      decoded: qr.decoded,
+      qrMetadata,
+      placement,
+      // Filled by the caller after any async normalize step.
+      ...normalizedQr !== void 0 ? { normalizedQr } : {}
+    },
+    validation,
+    bestPlacement
+  };
+}
+function findBestInsetPlacement(regionMask, totalModules, fallback) {
+  try {
+    const placement = placeQr(regionMask, totalModules);
+    return { x: placement.x, y: placement.y, size: placement.size, rotation: placement.rotation };
+  } catch (error) {
+    if (error instanceof QrPosterError) {
+      return {
+        ...fallback,
+        x: Math.round(regionMask.centroid.x - fallback.size / 2),
+        y: Math.round(regionMask.centroid.y - fallback.size / 2)
+      };
+    }
+    throw error;
+  }
+}
+function suggestPlacement(regionMask, totalModules) {
+  const bounds = regionMask.bounds;
+  const pitch = Math.max(4, Math.floor(Math.min(bounds.width, bounds.height) / totalModules));
+  const size = pitch * totalModules;
+  return {
+    x: Math.round(bounds.x + (bounds.width - size) / 2),
+    y: Math.round(bounds.y + (bounds.height - size) / 2),
+    size,
+    rotation: 0
+  };
+}
+async function resolveBuffers(imaging2, input) {
+  const source = await prepareSource(imaging2, input.posterBytes, input.maskBytes);
+  const qr = await resolveQr(imaging2, input);
+  const settings = { ...engineDefaults, ...input.settings };
+  const { layout, validation } = applyPlacement({ source, qr, input, settings });
+  if (!validation) layout.normalizedQr = await normalizeQr(qr.qrSource, layout.placement.size);
+  return { layout, validation };
+}
+async function assemblePayload(imaging2, input) {
+  const flat = {
+    seed: input.seed,
+    qrMargin: input.qrMargin,
+    plateCorners: input.plateCorners,
+    regionMargin: input.regionMargin ?? input.settings?.regionMargin ?? engineDefaults.regionMargin,
+    rimModules: input.rimModules ?? input.settings?.rimModules ?? engineDefaults.rimModules,
+    rimRounded: input.rimRounded ?? input.settings?.rimRounded ?? engineDefaults.rimRounded,
+    ecc: input.ecc ?? input.settings?.ecc ?? engineDefaults.ecc,
+    pixelStyle: input.pixelStyle ?? input.settings?.pixelStyle ?? engineDefaults.pixelStyle,
+    finderMarkers: input.finderMarkers ?? input.settings?.finderMarkers ?? engineDefaults.finderMarkers,
+    markerSub: input.markerSub ?? input.settings?.markerSub ?? engineDefaults.markerSub,
+    colors: input.colors ?? input.settings?.colors ?? engineDefaults.colors
+  };
+  const { layout, validation } = await resolveBuffers(imaging2, {
+    ...input,
+    previousTotalModules: void 0,
+    settings: flat
+  });
+  if (validation) throw new QrPosterError("QR_LAYOUT_INVALID", validation);
+  const result = await assembleResolved(layout, {
+    seed: flat.seed,
+    qrMargin: flat.qrMargin,
+    radius: flat.plateCorners === "light" ? 0 : layout.placement.modulePixels * 2,
+    regionMargin: flat.regionMargin,
+    rimModules: flat.rimModules,
+    rimRounded: flat.rimRounded,
+    pixelStyle: flat.pixelStyle,
+    transparentBlank: input.transparentBlank ?? false,
+    palette: flat.colors
+  });
+  if (!result.report.qualified)
+    throw new QrPosterError(
+      "VERIFICATION_FAILED",
+      `Pixel verification failed (${result.report.verification.checks.filter((c) => !c.passed).map((c) => c.name).join(", ")}). Adjust the placement and try again.`,
+      4
+    );
+  const artifacts = Object.fromEntries(
+    Object.entries(result.artifacts).map(([name, bytes]) => [name, bytesToBlob(name, bytes)])
+  );
+  artifacts["poster.svg"] = bytesToBlob(
+    "poster.svg",
+    new TextEncoder().encode(
+      buildPosterSvg(result.artifacts["poster.png"], layout.poster.width, layout.poster.height)
+    )
+  );
+  return {
+    report: result.report,
+    artifacts
+  };
+}
+
+// src/recipe.ts
+var RECIPE_FORMAT = "mahu-qr-recipe";
+var RECIPE_SCHEMA_VERSION = 1;
+var RECIPE_RENDERER_VERSION = "mahu-qr-renderer-1";
+var MAX_RECIPE_BYTES = 28 * 1024 * 1024;
+var MAX_BASE64_IMAGE_CHARS = Math.ceil(MAX_IMAGE_BYTES / 3) * 4;
+var digestSchema = z2.string().regex(/^[0-9a-f]{64}$/);
+var embeddedPngSchema = z2.object({
+  mimeType: z2.literal("image/png"),
+  encoding: z2.literal("base64"),
+  sha256: digestSchema,
+  data: z2.string().min(4).max(MAX_BASE64_IMAGE_CHARS)
+}).strict();
+var recipeSchema = z2.object({
+  format: z2.literal(RECIPE_FORMAT),
+  schemaVersion: z2.literal(RECIPE_SCHEMA_VERSION),
+  rendererVersion: z2.literal(RECIPE_RENDERER_VERSION),
+  content: contentSchema,
+  source: z2.object({
+    poster: embeddedPngSchema,
+    regionMask: embeddedPngSchema,
+    width: z2.number().int().positive().max(MAX_PIXELS),
+    height: z2.number().int().positive().max(MAX_PIXELS),
+    transparentBlank: z2.boolean()
+  }).strict().refine(({ width, height }) => width * height <= MAX_PIXELS, "Image exceeds the pixel limit."),
+  placement: placementSchema,
+  settings: settingsSchema
+}).strict();
+function fromBase64(value) {
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+    throw new Error("Recipe image data is not valid base64.");
+  const binary = atob(value);
+  if (binary.length > MAX_IMAGE_BYTES) throw new Error("Recipe PNG must be 10 MiB or smaller.");
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+async function sha256Hex(bytes) {
+  const digest = await crypto.subtle.digest("SHA-256", bytes.slice().buffer);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function renderRecipe(imaging2, rawRecipe, artifact) {
+  const recipe = recipeSchema.parse(rawRecipe);
+  const poster = fromBase64(recipe.source.poster.data);
+  const regionMask = fromBase64(recipe.source.regionMask.data);
+  const [posterSha, maskSha] = await Promise.all([sha256Hex(poster), sha256Hex(regionMask)]);
+  if (posterSha !== recipe.source.poster.sha256 || maskSha !== recipe.source.regionMask.sha256)
+    throw new Error("Recipe image digest does not match its bytes.");
+  const posterHeader = parsePngHeader(poster, "poster");
+  const maskHeader = parsePngHeader(regionMask, "mask");
+  if (posterHeader.width !== recipe.source.width || posterHeader.height !== recipe.source.height || maskHeader.width !== recipe.source.width || maskHeader.height !== recipe.source.height)
+    throw new Error("Recipe image dimensions do not match the declared dimensions.");
+  const settings = recipe.settings;
+  const assembled = await assemblePayload(imaging2, {
+    posterBytes: poster,
+    maskBytes: regionMask,
+    transparentBlank: recipe.source.transparentBlank,
+    content: recipe.content,
+    placement: recipe.placement,
+    ...settings
+  });
+  const png = assembled.artifacts[artifact];
+  if (!png) throw new Error(`Renderer did not produce ${artifact}.`);
+  return { png, filename: artifact };
+}
+
+// src/node.ts
+async function renderRecipeJson(rawRecipe, options = {}) {
+  const artifact = options.artifact ?? "poster.png";
+  const result = await renderRecipe(nodeImaging, rawRecipe, artifact);
+  return { png: new Uint8Array(await result.png.arrayBuffer()), filename: result.filename };
+}
+async function renderRecipeFile(input, options = {}) {
+  const inputBytes = typeof input === "string" ? Buffer2.byteLength(input, "utf8") : input.byteLength;
+  if (inputBytes > MAX_RECIPE_BYTES) {
+    throw new Error(`Recipe exceeds the ${MAX_RECIPE_BYTES}-byte size limit.`);
+  }
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const rawRecipe = JSON.parse(text);
+  return renderRecipeJson(rawRecipe, options);
+}
+export {
+  renderRecipeFile,
+  renderRecipeJson
+};