quadqr-js 1.0.2 → 1.3.0

package/dist/quadqr.min.js

@@ -1190,6 +1190,31 @@ function detectFinderCandidates(binary, width, height, options = {}) {
   return clusterFinderCandidates(raw, minConfirmations);
 }
 
+function recoverFinderSetFromTwo(binary, width, height, strongFinders, detector = {}) {
+  if (strongFinders.length !== 2) return strongFinders;
+  const moduleMean = (strongFinders[0].moduleSize + strongFinders[1].moduleSize) / 2;
+  const loose = detectFinderCandidates(binary, width, height, {
+    toleranceScale: Math.max(1.45, (detector.toleranceScale ?? 1) * 1.35),
+    moduleSpreadLimit: Math.max(0.72, detector.moduleSpreadLimit ?? 0.45),
+    minConfirmations: 1
+  });
+
+  const extra = loose.filter((candidate) => {
+    const moduleRatio = Math.abs(candidate.moduleSize - moduleMean) / Math.max(candidate.moduleSize, moduleMean);
+    if (moduleRatio > 0.62) return false;
+    return strongFinders.every((known) =>
+      Math.hypot(candidate.x - known.x, candidate.y - known.y) > Math.max(moduleMean, known.moduleSize) * 5
+    );
+  }).slice(0, 12);
+
+  if (!extra.length) return strongFinders;
+  return strongFinders.concat(extra).sort((a, b) =>
+    (b.confirmations - a.confirmations) ||
+    (a.score - b.score) ||
+    (b.moduleSize - a.moduleSize)
+  );
+}
+
 function dot(a, b) {
   return a.x * b.x + a.y * b.y;
 }
@@ -1272,6 +1297,14 @@ function alignmentTemplateValue(pattern, r, c) {
   return alignmentPatternIsBlack(pattern, r, c) ? 1 : 0;
 }
 
+const ALIGNMENT_SUBCELL_PROBES = Object.freeze([
+  Object.freeze([0, 0]),
+  Object.freeze([-0.32, 0]),
+  Object.freeze([0.32, 0]),
+  Object.freeze([0, -0.32]),
+  Object.freeze([0, 0.32])
+]);
+
 function alignmentScore(binary, width, height, center, basisU, basisV, scale, pattern) {
   let matches = 0;
   let total = 0;
@@ -1289,7 +1322,31 @@ function alignmentScore(binary, width, height, center, basisU, basisV, scale, pa
   return total ? matches / total : 0;
 }
 
-function searchAlignment(binary, width, height, triple, version) {
+function preciseAlignmentScore(binary, width, height, center, basisU, basisV, scale, pattern) {
+  let matches = 0;
+  let total = 0;
+  const radius = alignmentPatternRadius(pattern);
+  for (let r = -radius; r <= radius; r++) {
+    for (let c = -radius; c <= radius; c++) {
+      const expected = alignmentTemplateValue(pattern, r, c);
+      // Centre-only alignment scoring has a broad plateau: a candidate can be
+      // wrong by almost half a module while every centre still lands in the
+      // correct solid tile. This denser score is reserved for the slow recovery
+      // path, where Triangle16 needs sub-module geometry precision.
+      for (const [du, dv] of ALIGNMENT_SUBCELL_PROBES) {
+        const x = center.x + basisU.x * (c + du) * scale + basisV.x * (r + dv) * scale;
+        const y = center.y + basisU.y * (c + du) * scale + basisV.y * (r + dv) * scale;
+        const value = sampleBinaryAt(binary, width, height, x, y);
+        if (value === null) continue;
+        total++;
+        if (value === expected) matches++;
+      }
+    }
+  }
+  return total ? matches / total : 0;
+}
+
+function searchAlignment(binary, width, height, triple, version, options = {}) {
   const size = sizeForVersion(version);
   const separation = size - 7;
   const basisU = {
@@ -1309,8 +1366,12 @@ function searchAlignment(binary, width, height, triple, version) {
   };
 
   let best = { score: 0, center: predicted, scale: 1 };
-  const offsets = [-2.5, -1.5, -0.75, 0, 0.75, 1.5, 2.5];
+  const precise = options.preciseAlignment === true;
+  const offsets = precise
+    ? [-2.5, -1.5, -0.75, -0.5, -0.25, 0, 0.25, 0.5, 0.75, 1.5, 2.5]
+    : [-2.5, -1.5, -0.75, 0, 0.75, 1.5, 2.5];
   const scales = [0.72, 0.85, 1, 1.15, 1.3];
+  const scoreAlignment = precise ? preciseAlignmentScore : alignmentScore;
 
   for (const ou of offsets) {
     for (const ov of offsets) {
@@ -1319,7 +1380,7 @@ function searchAlignment(binary, width, height, triple, version) {
         y: predicted.y + basisU.y * ou + basisV.y * ov
       };
       for (const scale of scales) {
-        const score = alignmentScore(binary, width, height, center, basisU, basisV, scale, target);
+        const score = scoreAlignment(binary, width, height, center, basisU, basisV, scale, target);
         if (score > best.score) best = { score, center, scale };
       }
     }
@@ -1362,6 +1423,183 @@ function scoreAlignmentGrid(binary, width, height, homography, version) {
   return { score, patternScores };
 }
 
+function localProjectiveBasis(homography, moduleX, moduleY) {
+  const center = projectPoint(homography, moduleX, moduleY);
+  const alongU = projectPoint(homography, moduleX + 1, moduleY);
+  const alongV = projectPoint(homography, moduleX, moduleY + 1);
+  return {
+    center,
+    basisU: { x: alongU.x - center.x, y: alongU.y - center.y },
+    basisV: { x: alongV.x - center.x, y: alongV.y - center.y }
+  };
+}
+
+function searchProjectedAlignment(binary, width, height, homography, pattern) {
+  const moduleX = pattern.col + 0.5;
+  const moduleY = pattern.row + 0.5;
+  const local = localProjectiveBasis(homography, moduleX, moduleY);
+  const moduleScale = Math.max(
+    0.5,
+    (Math.hypot(local.basisU.x, local.basisU.y) + Math.hypot(local.basisV.x, local.basisV.y)) / 2
+  );
+  const offsets = [-1, -0.5, 0, 0.5, 1];
+  const scales = [0.88, 1, 1.12];
+  let best = {
+    score: projectedAlignmentScore(binary, width, height, homography, pattern),
+    center: local.center,
+    scale: 1,
+    offsetU: 0,
+    offsetV: 0,
+    displacementModules: 0
+  };
+
+  for (const offsetU of offsets) {
+    for (const offsetV of offsets) {
+      const center = {
+        x: local.center.x + local.basisU.x * offsetU + local.basisV.x * offsetV,
+        y: local.center.y + local.basisU.y * offsetU + local.basisV.y * offsetV
+      };
+      for (const scale of scales) {
+        const score = alignmentScore(
+          binary,
+          width,
+          height,
+          center,
+          local.basisU,
+          local.basisV,
+          scale,
+          pattern
+        );
+        if (score > best.score) {
+          best = {
+            score,
+            center,
+            scale,
+            offsetU,
+            offsetV,
+            displacementModules: Math.hypot(offsetU, offsetV),
+            displacementPixels: Math.hypot(offsetU, offsetV) * moduleScale
+          };
+        }
+      }
+    }
+  }
+
+  return best;
+}
+
+function refineHomographyWithAlignmentGrid(
+  binary,
+  width,
+  height,
+  initialHomography,
+  version,
+  sourcePoints,
+  destinationPoints,
+  initialGrid,
+  options = {}
+) {
+  const patterns = alignmentPatternCentersForVersion(version);
+  if (patterns.length <= 1 || options.alignmentRefinement === false) {
+    return {
+      homography: initialHomography,
+      grid: initialGrid,
+      refined: false,
+      points: []
+    };
+  }
+
+  const primary = patterns.find((pattern) => pattern.primary);
+  const secondaries = patterns.filter((pattern) => !pattern.primary);
+  const minimumScore = options.alignmentRefinePatternThreshold ?? 0.84;
+  const maxPoints = Math.max(1, Math.min(18, Math.round(options.alignmentRefineMaxPoints ?? 12)));
+  const candidates = [];
+
+  for (const pattern of secondaries) {
+    const found = searchProjectedAlignment(binary, width, height, initialHomography, pattern);
+    if (found.score < minimumScore) continue;
+    if (found.displacementModules > (options.alignmentRefineMaxDisplacement ?? 1.45)) continue;
+    candidates.push({ pattern, ...found });
+  }
+
+  if (!candidates.length) {
+    return { homography: initialHomography, grid: initialGrid, refined: false, points: [] };
+  }
+
+  // Prefer confident references, but retain spatial distribution so dense
+  // versions use alignment information across the entire matrix rather than
+  // allowing a cluster of nearby markers to dominate the fit.
+  candidates.sort((a, b) =>
+    (b.score - a.score) ||
+    ((b.pattern.row + b.pattern.col) - (a.pattern.row + a.pattern.col))
+  );
+  const selected = [];
+  for (const candidate of candidates) {
+    if (selected.length >= maxPoints) break;
+    const tooClose = selected.some((item) =>
+      Math.hypot(item.pattern.col - candidate.pattern.col, item.pattern.row - candidate.pattern.row) < 6
+    );
+    if (!tooClose || selected.length < 3) selected.push(candidate);
+  }
+  if (!selected.length) return { homography: initialHomography, grid: initialGrid, refined: false, points: [] };
+
+  const refinedSource = sourcePoints.slice();
+  const refinedDestination = destinationPoints.slice();
+  const weights = [4, 4, 4, 5];
+  const pointInfo = [];
+
+  for (const candidate of selected) {
+    refinedSource.push(candidate.center);
+    refinedDestination.push({
+      x: candidate.pattern.col + 0.5,
+      y: candidate.pattern.row + 0.5
+    });
+    // A 3x3 marker carries less evidence than the 5x5 primary and the three
+    // finder patterns, so it helps average geometry without overpowering them.
+    weights.push(0.8 + candidate.score * 1.7);
+    pointInfo.push({
+      row: candidate.pattern.row,
+      col: candidate.pattern.col,
+      score: candidate.score,
+      x: candidate.center.x,
+      y: candidate.center.y,
+      displacementModules: candidate.displacementModules
+    });
+  }
+
+  let refinedHomography;
+  try {
+    refinedHomography = computeHomographyLeastSquares(refinedSource, refinedDestination, weights);
+  } catch {
+    return { homography: initialHomography, grid: initialGrid, refined: false, points: [] };
+  }
+
+  const refinedGrid = scoreAlignmentGrid(binary, width, height, refinedHomography, version);
+  const primaryBefore = primary
+    ? projectedAlignmentScore(binary, width, height, initialHomography, primary)
+    : 1;
+  const primaryAfter = primary
+    ? projectedAlignmentScore(binary, width, height, refinedHomography, primary)
+    : 1;
+  const allowedGridDrop = options.alignmentRefineAllowedGridDrop ?? 0.006;
+  const allowedPrimaryDrop = options.alignmentRefineAllowedPrimaryDrop ?? 0.04;
+
+  if (
+    refinedGrid.score + allowedGridDrop < initialGrid.score ||
+    primaryAfter + allowedPrimaryDrop < primaryBefore
+  ) {
+    return { homography: initialHomography, grid: initialGrid, refined: false, points: [] };
+  }
+
+  return {
+    homography: refinedHomography,
+    grid: refinedGrid,
+    refined: true,
+    points: pointInfo,
+    initialGridScore: initialGrid.score
+  };
+}
+
 function solveLinearSystemFloat(matrix, vector) {
   const n = vector.length;
   const a = matrix.map((row, index) => row.slice().concat([vector[index]]));
@@ -1403,6 +1641,43 @@ function computeHomography(sourcePoints, destinationPoints) {
   return [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], 1];
 }
 
+function computeHomographyLeastSquares(sourcePoints, destinationPoints, weights = null) {
+  // Same destination -> source convention as computeHomography(), but accepts
+  // more than four correspondences and averages locator/alignment measurement
+  // noise. This is used only as a refinement after a valid four-point projective
+  // solution already exists.
+  assert(
+    sourcePoints.length === destinationPoints.length && sourcePoints.length >= 4,
+    "At least four matching point pairs are required."
+  );
+
+  const normal = Array.from({ length: 8 }, () => Array(8).fill(0));
+  const rhs = Array(8).fill(0);
+
+  const addEquation = (row, value, weight) => {
+    for (let i = 0; i < 8; i++) {
+      rhs[i] += row[i] * value * weight;
+      for (let j = 0; j < 8; j++) normal[i][j] += row[i] * row[j] * weight;
+    }
+  };
+
+  for (let i = 0; i < sourcePoints.length; i++) {
+    const u = destinationPoints[i].x;
+    const v = destinationPoints[i].y;
+    const x = sourcePoints[i].x;
+    const y = sourcePoints[i].y;
+    const weight = Math.max(0.05, Number(weights?.[i] ?? 1));
+    addEquation([u, v, 1, 0, 0, 0, -u * x, -v * x], x, weight);
+    addEquation([0, 0, 0, u, v, 1, -u * y, -v * y], y, weight);
+  }
+
+  // Tiny Tikhonov regularisation keeps near-degenerate noisy fits numerically
+  // stable without moving a normal QR-sized solution in any meaningful way.
+  for (let i = 0; i < 8; i++) normal[i][i] += 1e-9;
+  const h = solveLinearSystemFloat(normal, rhs);
+  return [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], 1];
+}
+
 function projectPoint(h, u, v) {
   const denominator = h[6] * u + h[7] * v + h[8];
   return {
@@ -1428,7 +1703,7 @@ function geometryCandidatesFromBinary(binary, width, height, finders, threshold,
     for (const item of versions) {
       const version = item.version;
       const size = sizeForVersion(version);
-      const alignment = searchAlignment(binary, width, height, triple, version);
+      const alignment = searchAlignment(binary, width, height, triple, version, options);
       if (alignment.score < (options.alignmentThreshold ?? 0.72)) continue;
 
       const alignmentTarget = alignment.target;
@@ -1452,8 +1727,34 @@ function geometryCandidatesFromBinary(binary, width, height, finders, threshold,
         continue;
       }
 
-      const alignmentGrid = scoreAlignmentGrid(binary, width, height, homography, version);
-      if (alignmentGrid.score < (options.alignmentGridThreshold ?? 0.68)) continue;
+      const initialAlignmentGrid = scoreAlignmentGrid(binary, width, height, homography, version);
+      const alignmentGridThreshold = options.alignmentGridThreshold ?? 0.68;
+      const refinementFloor = Math.max(0, alignmentGridThreshold - (options.alignmentRefineCandidateMargin ?? 0.10));
+      const skipRefinementScore = options.alignmentRefineSkipScore ?? 0.985;
+      const refinement = (
+        initialAlignmentGrid.score >= refinementFloor &&
+        initialAlignmentGrid.score < skipRefinementScore
+      )
+        ? refineHomographyWithAlignmentGrid(
+            binary,
+            width,
+            height,
+            homography,
+            version,
+            src,
+            dest,
+            initialAlignmentGrid,
+            options
+          )
+        : {
+            homography,
+            grid: initialAlignmentGrid,
+            refined: false,
+            points: []
+          };
+      homography = refinement.homography;
+      const alignmentGrid = refinement.grid;
+      if (alignmentGrid.score < alignmentGridThreshold) continue;
 
       const versionPenalty = item.error / 4;
       const alignmentConfidence = 0.55 * alignment.score + 0.45 * alignmentGrid.score;
@@ -1472,6 +1773,9 @@ function geometryCandidatesFromBinary(binary, width, height, finders, threshold,
           target: { row: alignmentTarget.row, col: alignmentTarget.col },
           patterns: alignmentGrid.patternScores.length,
           gridScore: alignmentGrid.score,
+          initialGridScore: refinement.initialGridScore ?? initialAlignmentGrid.score,
+          refined: refinement.refined,
+          refinementPoints: refinement.points,
           patternScores: alignmentGrid.patternScores
         },
         threshold,
@@ -1543,19 +1847,21 @@ function detectCodeGeometry(imageData, options = {}) {
   const maxCandidates = options.maxCandidates ?? 8;
 
   const evaluatePass = (pass, recovery = false) => {
-    const finders = detectFinderCandidates(pass.binary, width, height, pass.detector ?? {});
-    const geometries = geometryCandidatesFromBinary(
+    const detector = pass.detector ?? {};
+    const finders = detectFinderCandidates(pass.binary, width, height, detector);
+    const geometryOptions = {
+      ...options,
+      finderMethod: pass.finderMethod,
+      alignmentThreshold: recovery ? 0.68 : 0.72,
+      alignmentGridThreshold: recovery ? 0.64 : 0.68
+    };
+    let geometries = geometryCandidatesFromBinary(
       pass.binary,
       width,
       height,
       finders,
       pass.threshold,
-      {
-        ...options,
-        finderMethod: pass.finderMethod,
-        alignmentThreshold: recovery ? 0.68 : 0.72,
-        alignmentGridThreshold: recovery ? 0.64 : 0.68
-      }
+      geometryOptions
     );
 
     pushFinderDiagnostic(
@@ -1565,6 +1871,35 @@ function detectCodeGeometry(imageData, options = {}) {
       finders,
       geometries
     );
+
+    // Dense codes under projective distortion can leave two finder patterns
+    // perfectly strong while the third is stretched enough to miss the normal
+    // 1:1:3:1:1 tolerance. Only in that very specific recovery state, run one
+    // bounded looser detector and let the normal three-finder geometry checks
+    // reject false data-cell lookalikes. The clean fast path is unchanged.
+    if (!geometries.length && recovery && finders.length === 2) {
+      const recoveredFinders = recoverFinderSetFromTwo(pass.binary, width, height, finders, detector);
+      if (recoveredFinders.length > 2) {
+        const finderMethod = `${pass.finderMethod}-two-finder-recovery`;
+        geometries = geometryCandidatesFromBinary(
+          pass.binary,
+          width,
+          height,
+          recoveredFinders,
+          pass.threshold,
+          { ...geometryOptions, finderMethod }
+        );
+        pushFinderDiagnostic(
+          { ...options, width, height, diagnosticLabel: `${options.diagnosticLabel ?? "perspective"}-two-finder` },
+          finderMethod,
+          pass.threshold,
+          recoveredFinders,
+          geometries
+        );
+        if (geometries.length) return { finders: recoveredFinders, geometries };
+      }
+    }
+
     return { finders, geometries };
   };
 
@@ -1580,6 +1915,38 @@ function detectCodeGeometry(imageData, options = {}) {
   if (fast.geometries.length) return fast.geometries.slice(0, maxCandidates);
   if (options.finderRecovery === false) return [];
 
+  // If the clean threshold already found exactly two strong locators, try the
+  // bounded perspective-tolerant third-finder pass before any color processing.
+  // This is substantially cheaper than Auto Color and targets the dense-code
+  // projective failure mode directly.
+  if (fast.finders.length === 2) {
+    const recoveredFinders = recoverFinderSetFromTwo(valueInfo.binary, width, height, fast.finders, {});
+    if (recoveredFinders.length > 2) {
+      const finderMethod = "rgb-value-otsu-two-finder-recovery";
+      const recoveredGeometries = geometryCandidatesFromBinary(
+        valueInfo.binary,
+        width,
+        height,
+        recoveredFinders,
+        valueInfo.threshold,
+        {
+          ...options,
+          finderMethod,
+          alignmentThreshold: 0.68,
+          alignmentGridThreshold: 0.64
+        }
+      );
+      pushFinderDiagnostic(
+        { ...options, width, height, diagnosticLabel: `${options.diagnosticLabel ?? "perspective"}-two-finder` },
+        finderMethod,
+        valueInfo.threshold,
+        recoveredFinders,
+        recoveredGeometries
+      );
+      if (recoveredGeometries.length) return recoveredGeometries.slice(0, maxCandidates);
+    }
+  }
+
   // Camera recovery #1: Photoshop Auto Color-style per-channel levels before
   // finder thresholding. Live camera frames are usually much larger than the
   // QR itself, so a single global histogram can be dominated by dark room/UI
@@ -1983,6 +2350,49 @@ function samplePerspectiveMatrix(imageData, homography, size, options = {}) {
   return { rgbGrid };
 }
 
+/**
+ * Sample the two protected regions of every Triangle16 module.
+ *
+ * Triangle16 uses a fixed "/" diagonal. Samples are intentionally placed well
+ * inside the upper-left and lower-right triangles, away from the diagonal and
+ * module borders. This makes the decoder much less sensitive to antialiasing,
+ * blur, resampling and small homography errors than center sampling.
+ */
+function samplePerspectiveTriangleMatrix(imageData, homography, size, options = {}) {
+  const triangleGrid = Array.from({ length: size }, () => new Array(size));
+  const mode = options.sampleMode ?? "cross";
+  const radius = options.highDensitySampleRadius ?? options.triangleSampleRadius ??
+    (mode === "median" ? 0.075 : 0.085);
+  const inset = Math.max(0.18, Math.min(0.36, Number(options.highDensitySampleInset ?? options.triangleSampleInset ?? 0.28)));
+  const firstOffset = inset;
+  const secondOffset = 1 - inset;
+  const offsetX = Number.isFinite(options.sampleOffsetX) ? options.sampleOffsetX : 0;
+  const offsetY = Number.isFinite(options.sampleOffsetY) ? options.sampleOffsetY : 0;
+  const sampler = mode === "median" ? robustProjectedSample : averageProjectedSample;
+
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      triangleGrid[r][c] = {
+        first: sampler(
+          imageData,
+          homography,
+          c + firstOffset + offsetX,
+          r + firstOffset + offsetY,
+          radius
+        ),
+        second: sampler(
+          imageData,
+          homography,
+          c + secondOffset + offsetX,
+          r + secondOffset + offsetY,
+          radius
+        )
+      };
+    }
+  }
+  return { triangleGrid };
+}
+
 function meanRgb(values) {
   if (!values.length) throw new Error("No calibration samples available.");
   return values.reduce(
@@ -2179,6 +2589,34 @@ function sampleAxisAlignedGrid(imageData, bounds, size, radiusRatio = 0.18) {
   return { rgbGrid, moduleWidth: moduleW, moduleHeight: moduleH };
 }
 
+function sampleAxisAlignedTriangleGrid(imageData, bounds, size, radiusRatio = 0.085, insetRatio = 0.28) {
+  const moduleW = bounds.width / size;
+  const moduleH = bounds.height / size;
+  const inset = Math.max(0.18, Math.min(0.36, insetRatio));
+  const radius = Math.max(0, Math.min(moduleW, moduleH) * radiusRatio);
+  const triangleGrid = Array.from({ length: size }, () => new Array(size));
+
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      triangleGrid[r][c] = {
+        first: sampleAverageAxis(
+          imageData,
+          bounds.x + (c + inset) * moduleW,
+          bounds.y + (r + inset) * moduleH,
+          radius
+        ),
+        second: sampleAverageAxis(
+          imageData,
+          bounds.x + (c + 1 - inset) * moduleW,
+          bounds.y + (r + 1 - inset) * moduleH,
+          radius
+        )
+      };
+    }
+  }
+  return { triangleGrid, moduleWidth: moduleW, moduleHeight: moduleH };
+}
+
 const visionInternals = Object.freeze({
   buildGray,
   otsuThreshold,
@@ -2191,21 +2629,21 @@ const visionInternals = Object.freeze({
   luminance
 });
 
-return { computeHomography, projectPoint, detectCodeGeometry, autoColorImageData, autoToneContrastColorRgbGrid, autoToneContrastColorImageData, samplePerspectiveMatrix, sampleObservedPalette, spatiallyNormalizeRgbGrid, rectifyImageData, findActiveBounds, sampleAxisAlignedGrid, visionInternals };
+return { computeHomography, projectPoint, detectCodeGeometry, autoColorImageData, autoToneContrastColorRgbGrid, autoToneContrastColorImageData, samplePerspectiveMatrix, samplePerspectiveTriangleMatrix, sampleObservedPalette, spatiallyNormalizeRgbGrid, rectifyImageData, findActiveBounds, sampleAxisAlignedGrid, sampleAxisAlignedTriangleGrid, visionInternals };
 })();
 const __qqr_quadqr_js = (function () {
 const { MAX_CODEWORD_SYMBOLS, rsEncode, rsDecode } = __qqr_reed_solomon_js;
 const { alignmentPatternCentersForVersion, alignmentPatternIsBlack, alignmentPatternRadius, sizeForVersion, versionFromSize } = __qqr_geometry_js;
-const { detectCodeGeometry, samplePerspectiveMatrix, rectifyImageData, sampleObservedPalette, spatiallyNormalizeRgbGrid, autoToneContrastColorRgbGrid, autoToneContrastColorImageData, autoColorImageData, findActiveBounds, sampleAxisAlignedGrid } = __qqr_vision_js;
+const { detectCodeGeometry, computeHomography, projectPoint, samplePerspectiveMatrix, samplePerspectiveTriangleMatrix, rectifyImageData, sampleObservedPalette, spatiallyNormalizeRgbGrid, autoToneContrastColorRgbGrid, autoToneContrastColorImageData, autoColorImageData, findActiveBounds, sampleAxisAlignedGrid, sampleAxisAlignedTriangleGrid } = __qqr_vision_js;
 const { decryptSecurePayload, encryptSecurePayload, inspectSecureEnvelope, SECURITY_MODES, SECURITY_ALGORITHMS, SECURE_PAYLOAD_VERSION, DEFAULT_PBKDF2_ITERATIONS, generateRaw256Key, normalizeRaw256Key, bytesToHex } = __qqr_security_js;
 /**
  * QuadQR
  *
- * Experimental four-state RGBW matrix code written in pure JavaScript.
+ * Experimental RGBW / Triangle16 matrix code written in pure JavaScript.
  *
  * Core format:
- * - Red / Green / Blue / White data cells
- * - exactly 2 bits per data cell
+ * - RGBW profile: Red / Green / Blue / White, exactly 2 bits per data cell
+ * - Triangle16 profile: two fixed RGBW triangle regions, 16 states / 4 bits per body data cell
  * - GF(256) Reed-Solomon ECC over byte symbols
  * - interleaved body ECC blocks
  * - zero-overhead spectral-spatial cell placement
@@ -2220,6 +2658,33 @@ const MIN_VERSION = 1;
 const MAX_VERSION = 40;
 const DEFAULT_ECC_LEVEL = "M";
 
+const RENDER_MODES = Object.freeze({
+  SCREEN: "screen",
+  PRINT: "print"
+});
+
+const CELL_ENCODINGS = Object.freeze({
+  RGBW: "rgbw",
+  TRIANGLE16: "triangle16"
+});
+
+// Print-safe defaults deliberately use darker, more ink-tolerant primaries and
+// a true white background. Applications can still override individual colors.
+const PRINT_PALETTE = Object.freeze({
+  black: "#000000",
+  white: "#ffffff",
+  red: "#d71932",
+  green: "#087f3e",
+  blue: "#174ea6"
+});
+
+const COMPRESSION_MODES = Object.freeze({
+  NONE: "none",
+  AUTO: "auto",
+  LZ: "lz"
+});
+const SIGNATURE_ALGORITHMS = Object.freeze({ ED25519: "Ed25519" });
+
 // Data cells are the four values 0..3. Structural white deliberately shares
 // value 3 with data-white because both render and scan identically.
 const CELL = Object.freeze({
@@ -2260,8 +2725,10 @@ const MAGIC = new Uint8Array([0x51, 0x51, 0x52, 0x57]); // QQRW (QuadQR RGBW)
 const HEADER_BYTES = 10;
 const HEADER_RS_PARITY = 8;
 const HEADER_CODEWORD_BYTES = HEADER_BYTES + HEADER_RS_PARITY;
-const CELLS_PER_BYTE = 4;
-const HEADER_CODEWORD_CELLS = HEADER_CODEWORD_BYTES * CELLS_PER_BYTE;
+const RGBW_CELLS_PER_BYTE = 4;
+const TRIANGLE16_CELLS_PER_BYTE = 2;
+const CELLS_PER_BYTE = RGBW_CELLS_PER_BYTE; // legacy internal alias
+const HEADER_CODEWORD_CELLS = HEADER_CODEWORD_BYTES * RGBW_CELLS_PER_BYTE;
 
 // Version 1 is a deliberately compact small-symbol profile. A 21x21 matrix
 // cannot afford the normal 18-byte protected header plus a 24-byte M body
@@ -2273,7 +2740,7 @@ const COMPACT_HEADER_MAGIC = 0xc3;
 const COMPACT_HEADER_BYTES = 4;
 const COMPACT_HEADER_RS_PARITY = 4;
 const COMPACT_HEADER_CODEWORD_BYTES = COMPACT_HEADER_BYTES + COMPACT_HEADER_RS_PARITY;
-const COMPACT_HEADER_CODEWORD_CELLS = COMPACT_HEADER_CODEWORD_BYTES * CELLS_PER_BYTE;
+const COMPACT_HEADER_CODEWORD_CELLS = COMPACT_HEADER_CODEWORD_BYTES * RGBW_CELLS_PER_BYTE;
 const COMPACT_ECC_LEVELS = Object.freeze({
   L: Object.freeze({ paritySymbols: 4, correctableSymbolsPerBlock: 2 }),
   M: Object.freeze({ paritySymbols: 8, correctableSymbolsPerBlock: 4 }),
@@ -2284,6 +2751,23 @@ const COMPACT_ECC_LEVELS = Object.freeze({
 const CRC_BYTES = 4;
 const TEXT_FLAG = 1;
 const SECURE_FLAG = 1 << 3;
+const EXTENDED_PAYLOAD_FLAG = 1 << 4;
+const SIGNED_FLAG = 1 << 5;
+const TRIANGLE16_FLAG = 1 << 6;
+
+// Internal payload extension envelope. This is deliberately not a public
+// payload mode or content-type system. It exists only when compression or
+// signing needs metadata around an otherwise normal text/binary payload.
+const PAYLOAD_ENVELOPE_VERSION = 2;
+const PAYLOAD_ENVELOPE_MAGIC = new Uint8Array([0x51, 0x50, 0x58, 0x31]); // QPX1
+const PAYLOAD_ENVELOPE_HEADER_BYTES = 16;
+const PAYLOAD_ENVELOPE_SIGNED_FLAG = 1;
+const PAYLOAD_ENVELOPE_COMPRESSED_FLAG = 1 << 1;
+const PAYLOAD_ENVELOPE_EMBEDDED_KEY_FLAG = 1 << 2;
+const PAYLOAD_ENVELOPE_COMPRESSION_IDS = Object.freeze({ none: 0, lz: 1 });
+const PAYLOAD_ENVELOPE_COMPRESSION_BY_ID = Object.freeze({ 0: "none", 1: "lz" });
+const PAYLOAD_ENVELOPE_SIGNATURE_IDS = Object.freeze({ none: 0, Ed25519: 1 });
+const PAYLOAD_ENVELOPE_SIGNATURE_BY_ID = Object.freeze({ 0: null, 1: "Ed25519" });
 const ECC_SHIFT = 1;
 const ECC_MASK = 0b00000110;
 
@@ -2332,6 +2816,45 @@ function normalizeEccLevel(level = DEFAULT_ECC_LEVEL) {
   return value;
 }
 
+function normalizeCellEncoding(value = CELL_ENCODINGS.RGBW) {
+  const key = String(value).toLowerCase();
+  assert(
+    key === CELL_ENCODINGS.RGBW || key === CELL_ENCODINGS.TRIANGLE16,
+    `Internal cell encoding must be ${CELL_ENCODINGS.RGBW} or ${CELL_ENCODINGS.TRIANGLE16}.`
+  );
+  return key;
+}
+
+// Public API presents Triangle16 as one experimental High Density Mode toggle.
+// cellEncoding remains an internal/backward-compatible detail so existing
+// experimental branch symbols and renderer metadata continue to work.
+function cellEncodingFromOptions(options = {}) {
+  if (typeof options.highDensity === "boolean") {
+    return options.highDensity ? CELL_ENCODINGS.TRIANGLE16 : CELL_ENCODINGS.RGBW;
+  }
+  return normalizeCellEncoding(options.cellEncoding ?? CELL_ENCODINGS.RGBW);
+}
+
+function cellsPerByteForEncoding(cellEncoding = CELL_ENCODINGS.RGBW) {
+  return normalizeCellEncoding(cellEncoding) === CELL_ENCODINGS.TRIANGLE16
+    ? TRIANGLE16_CELLS_PER_BYTE
+    : RGBW_CELLS_PER_BYTE;
+}
+
+function packTriangleCell(first, second) {
+  assert(first >= 0 && first <= 3 && second >= 0 && second <= 3, "Invalid Triangle16 color.");
+  return ((first & 3) << 2) | (second & 3);
+}
+
+function unpackTriangleCell(value) {
+  assert(Number.isInteger(value) && value >= 0 && value <= 15, "Invalid Triangle16 data cell.");
+  return { first: (value >>> 2) & 3, second: value & 3 };
+}
+
+function solidTriangleCell(color) {
+  return packTriangleCell(color, color);
+}
+
 function concatBytes(...arrays) {
   const total = arrays.reduce((sum, item) => sum + item.length, 0);
   const out = new Uint8Array(total);
@@ -2362,6 +2885,367 @@ function readU32be(bytes, offset = 0) {
   ) >>> 0;
 }
 
+function u16be(value) {
+  const v = Number(value) >>> 0;
+  assert(v <= 0xffff, "Value does not fit in uint16.");
+  return new Uint8Array([(v >>> 8) & 0xff, v & 0xff]);
+}
+
+function readU16be(bytes, offset = 0) {
+  return ((bytes[offset] << 8) | bytes[offset + 1]) >>> 0;
+}
+
+function normalizeCompressionMode(value = "none") {
+  const key = String(value).toLowerCase();
+  assert(["none", "auto", "lz"].includes(key), "compression must be none, auto, or lz.");
+  return key;
+}
+
+function asBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  return new Uint8Array(input);
+}
+
+/** Portable LZSS-style compressor used by QuadQR payload compression. */
+function compressPayload(input) {
+  const bytes = asBytes(input);
+  if (bytes.length < 4) return bytes.slice();
+  const out = [];
+  const recent = new Map();
+  let pos = 0;
+
+  const keyAt = (i) => i + 2 < bytes.length ? ((bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]) : -1;
+  const remember = (i) => {
+    const key = keyAt(i);
+    if (key < 0) return;
+    let list = recent.get(key);
+    if (!list) recent.set(key, list = []);
+    list.push(i);
+    while (list.length > 32) list.shift();
+    while (list.length && i - list[0] > 4095) list.shift();
+  };
+
+  while (pos < bytes.length) {
+    const flagIndex = out.length;
+    out.push(0);
+    let flags = 0;
+    for (let token = 0; token < 8 && pos < bytes.length; token++) {
+      let bestLength = 0;
+      let bestOffset = 0;
+      const key = keyAt(pos);
+      const candidates = key >= 0 ? (recent.get(key) ?? []) : [];
+      for (let ci = candidates.length - 1; ci >= 0; ci--) {
+        const candidate = candidates[ci];
+        const offset = pos - candidate;
+        if (offset <= 0 || offset > 4095) continue;
+        let length = 0;
+        while (length < 18 && pos + length < bytes.length && bytes[candidate + length] === bytes[pos + length]) length++;
+        if (length >= 3 && length > bestLength) {
+          bestLength = length;
+          bestOffset = offset;
+          if (length === 18) break;
+        }
+      }
+
+      if (bestLength >= 3) {
+        flags |= (1 << token);
+        const encoded = ((bestOffset & 0x0fff) << 4) | ((bestLength - 3) & 0x0f);
+        out.push((encoded >>> 8) & 0xff, encoded & 0xff);
+        for (let i = 0; i < bestLength; i++) remember(pos + i);
+        pos += bestLength;
+      } else {
+        out.push(bytes[pos]);
+        remember(pos);
+        pos++;
+      }
+    }
+    out[flagIndex] = flags;
+  }
+  return Uint8Array.from(out);
+}
+
+function decompressPayload(input, expectedLength = null) {
+  const bytes = asBytes(input);
+  const out = [];
+  let pos = 0;
+  while (pos < bytes.length) {
+    const flags = bytes[pos++];
+    for (let token = 0; token < 8 && pos < bytes.length; token++) {
+      if (flags & (1 << token)) {
+        assert(pos + 1 < bytes.length, "Compressed payload is truncated.");
+        const encoded = (bytes[pos++] << 8) | bytes[pos++];
+        const offset = (encoded >>> 4) & 0x0fff;
+        const length = (encoded & 0x0f) + 3;
+        assert(offset > 0 && offset <= out.length, "Compressed payload has an invalid back-reference.");
+        for (let i = 0; i < length; i++) out.push(out[out.length - offset]);
+      } else {
+        out.push(bytes[pos++]);
+      }
+      if (expectedLength != null && out.length >= expectedLength) break;
+    }
+  }
+  if (expectedLength != null) assert(out.length === expectedLength, "Decompressed payload length mismatch.");
+  return Uint8Array.from(out);
+}
+
+function prepareCompressedBody(payload, compression = "none") {
+  const mode = normalizeCompressionMode(compression);
+  if (mode === "none") return { body: payload, compression: "none" };
+  const compressed = compressPayload(payload);
+  if (mode === "auto" && compressed.length >= payload.length - 2) {
+    return { body: payload, compression: "none" };
+  }
+  return { body: compressed, compression: "lz" };
+}
+
+function normalizeSigningKeyId(value) {
+  if (value == null || value === false || value === "") return new Uint8Array(0);
+  const bytes = typeof value === "string" ? getTextEncoder().encode(value) : asBytes(value);
+  assert(bytes.length <= 64, "Signing key ID must be 64 bytes or fewer.");
+  return bytes;
+}
+
+function makePayloadEnvelopeHeader({ compression, flags = 0, originalLength, keyIdLength = 0, publicKeyLength = 0, signatureLength = 0, signatureAlgorithm = null, version = PAYLOAD_ENVELOPE_VERSION }) {
+  assert(keyIdLength <= 0xff, "Signing key ID is too long.");
+  assert(publicKeyLength <= 0xff, "Signing public key is too large.");
+  assert(signatureLength <= 0xff, "Signature is too large.");
+  const header = new Uint8Array(PAYLOAD_ENVELOPE_HEADER_BYTES);
+  header.set(PAYLOAD_ENVELOPE_MAGIC, 0);
+  header[4] = version;
+  header[5] = flags & 0xff;
+  header[6] = PAYLOAD_ENVELOPE_COMPRESSION_IDS[compression];
+  header[7] = PAYLOAD_ENVELOPE_SIGNATURE_IDS[signatureAlgorithm ?? "none"] ?? 0;
+  header.set(u32be(originalLength), 8);
+  header[12] = keyIdLength;
+  header[13] = publicKeyLength;
+  header[14] = signatureLength;
+  header[15] = 0;
+  return header;
+}
+
+function isPayloadEnvelope(input) {
+  const bytes = asBytes(input);
+  return bytes.length >= PAYLOAD_ENVELOPE_HEADER_BYTES && PAYLOAD_ENVELOPE_MAGIC.every((value, index) => bytes[index] === value);
+}
+
+function packPayloadEnvelope(input, options = {}) {
+  const payload = asBytes(input);
+  const prepared = prepareCompressedBody(payload, options.compression ?? "none");
+  const flags = prepared.compression !== "none" ? PAYLOAD_ENVELOPE_COMPRESSED_FLAG : 0;
+  const header = makePayloadEnvelopeHeader({
+    compression: prepared.compression,
+    flags,
+    originalLength: payload.length
+  });
+  return concatBytes(header, prepared.body);
+}
+
+function parsePayloadEnvelope(input) {
+  const container = asBytes(input);
+  assert(isPayloadEnvelope(container), "Payload extension envelope is not recognized.");
+  const version = container[4];
+  assert(version === 1 || version === PAYLOAD_ENVELOPE_VERSION, `Unsupported payload extension version ${version}.`);
+  const flags = container[5];
+  const compression = PAYLOAD_ENVELOPE_COMPRESSION_BY_ID[container[6]];
+  assert(compression != null, `Unknown payload compression id ${container[6]}.`);
+  const signatureAlgorithm = PAYLOAD_ENVELOPE_SIGNATURE_BY_ID[container[7]];
+  const originalLength = readU32be(container, 8);
+  const metadataLength = container[12];
+  const publicKeyLength = container[13];
+  const signatureLength = container[14];
+  let offset = PAYLOAD_ENVELOPE_HEADER_BYTES;
+  const endMetadata = offset + metadataLength;
+  const endPublicKey = endMetadata + publicKeyLength;
+  const endSignature = endPublicKey + signatureLength;
+  assert(endSignature <= container.length, "Payload extension length fields exceed the envelope size.");
+  const metadataBytes = container.slice(offset, endMetadata);
+  const publicKey = container.slice(endMetadata, endPublicKey);
+  const signature = container.slice(endPublicKey, endSignature);
+  const stored = container.slice(endSignature);
+  const payload = compression === "lz" ? decompressPayload(stored, originalLength) : stored;
+  assert(payload.length === originalLength, "Payload length mismatch after extension decoding.");
+  const signed = Boolean(flags & PAYLOAD_ENVELOPE_SIGNED_FLAG);
+  const signedBytes = signed ? concatBytes(container.slice(0, PAYLOAD_ENVELOPE_HEADER_BYTES), metadataBytes, publicKey, stored) : null;
+
+  // v1 used byte 12 for a human-readable signer label and always embedded
+  // the public key. v2 uses the same field for a compact key ID and makes
+  // public-key embedding optional.
+  const legacySigner = version === 1 && metadataLength ? getTextDecoder().decode(metadataBytes) : null;
+  const keyId = version >= 2 && metadataLength ? getTextDecoder().decode(metadataBytes) : null;
+  const keyIdHex = version >= 2 && metadataLength
+    ? Array.from(metadataBytes, (value) => value.toString(16).padStart(2, "0")).join("")
+    : null;
+
+  return {
+    container,
+    version,
+    compression,
+    compressed: compression !== "none",
+    originalBytes: originalLength,
+    storedBytes: stored.length,
+    savedBytes: originalLength - stored.length,
+    payload,
+    signed,
+    signer: legacySigner,
+    keyId,
+    keyIdHex,
+    publicKey,
+    hasEmbeddedPublicKey: publicKey.length > 0,
+    signature,
+    signatureAlgorithm,
+    signedBytes,
+    signatureVerified: signed ? null : undefined,
+    signatureTrusted: signed ? null : undefined
+  };
+}
+
+function subtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  assert(subtle, "Web Crypto is required for QuadQR signing.");
+  return subtle;
+}
+
+async function normalizeEd25519PublicKey(key) {
+  const subtle = subtleCrypto();
+  if (typeof CryptoKey !== "undefined" && key instanceof CryptoKey) return key;
+  if (key && typeof key === "object" && key.type === "public" && key.algorithm?.name === "Ed25519") return key;
+  const bytes = asBytes(key);
+  assert(bytes.length === 32, "Ed25519 public key must be a 32-byte raw key or CryptoKey.");
+  return subtle.importKey("raw", bytes, { name: "Ed25519" }, true, ["verify"]);
+}
+
+async function normalizeEd25519PrivateKey(key) {
+  const subtle = subtleCrypto();
+  if (typeof CryptoKey !== "undefined" && key instanceof CryptoKey) return key;
+  if (key && typeof key === "object" && key.type === "private" && key.algorithm?.name === "Ed25519") return key;
+  const bytes = asBytes(key);
+  return subtle.importKey("pkcs8", bytes, { name: "Ed25519" }, false, ["sign"]);
+}
+
+async function deriveSigningKeyId(publicKey, bytes = 8) {
+  const subtle = subtleCrypto();
+  const normalized = await normalizeEd25519PublicKey(publicKey);
+  const raw = new Uint8Array(await subtle.exportKey("raw", normalized));
+  const digest = new Uint8Array(await subtle.digest("SHA-256", raw));
+  const count = Math.max(4, Math.min(16, Math.floor(bytes)));
+  return Array.from(digest.slice(0, count), (value) => value.toString(16).padStart(2, "0")).join("");
+}
+
+async function generateSigningKeyPair() {
+  const subtle = subtleCrypto();
+  const pair = await subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"]);
+  const publicKeyBytes = new Uint8Array(await subtle.exportKey("raw", pair.publicKey));
+  const privateKeyPkcs8 = new Uint8Array(await subtle.exportKey("pkcs8", pair.privateKey));
+  const keyId = await deriveSigningKeyId(pair.publicKey);
+  return {
+    privateKey: pair.privateKey,
+    publicKey: pair.publicKey,
+    privateKeyPkcs8,
+    publicKeyBytes,
+    keyId,
+    algorithm: "Ed25519"
+  };
+}
+
+async function packSignedPayloadEnvelope(input, options = {}) {
+  const payload = asBytes(input);
+  assert(options.privateKey, "privateKey is required to sign a QuadQR payload.");
+  const subtle = subtleCrypto();
+  const prepared = prepareCompressedBody(payload, options.compression ?? "auto");
+  const keyIdBytes = normalizeSigningKeyId(options.keyId);
+
+  let publicKeyBytes = new Uint8Array(0);
+  if (options.embedPublicKey) {
+    assert(options.publicKey, "publicKey is required when embedPublicKey is enabled.");
+    const publicKeyObject = await normalizeEd25519PublicKey(options.publicKey);
+    publicKeyBytes = new Uint8Array(await subtle.exportKey("raw", publicKeyObject));
+  }
+
+  const flags = PAYLOAD_ENVELOPE_SIGNED_FLAG |
+    (prepared.compression !== "none" ? PAYLOAD_ENVELOPE_COMPRESSED_FLAG : 0) |
+    (publicKeyBytes.length ? PAYLOAD_ENVELOPE_EMBEDDED_KEY_FLAG : 0);
+  const header = makePayloadEnvelopeHeader({
+    compression: prepared.compression,
+    flags,
+    originalLength: payload.length,
+    keyIdLength: keyIdBytes.length,
+    publicKeyLength: publicKeyBytes.length,
+    signatureLength: 64,
+    signatureAlgorithm: "Ed25519"
+  });
+  const signedBytes = concatBytes(header, keyIdBytes, publicKeyBytes, prepared.body);
+  const privateKey = await normalizeEd25519PrivateKey(options.privateKey);
+  const signature = new Uint8Array(await subtle.sign({ name: "Ed25519" }, privateKey, signedBytes));
+  assert(signature.length === 64, "Unexpected Ed25519 signature length.");
+  return concatBytes(header, keyIdBytes, publicKeyBytes, signature, prepared.body);
+}
+
+function lookupTrustedSigningKey(trustedKeys, keyId) {
+  if (!trustedKeys || !keyId) return null;
+  if (trustedKeys instanceof Map) return trustedKeys.get(keyId) ?? null;
+  if (typeof trustedKeys === "object") return trustedKeys[keyId] ?? null;
+  return null;
+}
+
+async function verifyPayloadEnvelopeSignature(input, options = {}) {
+  const parsed = input?.container && input?.signedBytes ? input : parsePayloadEnvelope(input);
+  assert(parsed.signed, "QuadQR payload is not signed.");
+  assert(parsed.signatureAlgorithm === "Ed25519", "Unsupported signature algorithm.");
+  const subtle = subtleCrypto();
+
+  let trusted = options.publicKey ?? options.trustedPublicKey ?? lookupTrustedSigningKey(options.trustedKeys, parsed.keyId);
+  let trustSource = trusted ? "external" : null;
+
+  // Legacy v1 symbols embedded the public key by default, so preserve their
+  // historical self-verification behavior. v2 requires explicit opt-in.
+  if (!trusted && parsed.publicKey.length && (parsed.version === 1 || options.allowEmbeddedKey === true)) {
+    trusted = parsed.publicKey;
+    trustSource = "embedded";
+  }
+
+  assert(
+    trusted,
+    parsed.keyId
+      ? `A trusted Ed25519 public key is required to verify signing key ID "${parsed.keyId}".`
+      : "A trusted Ed25519 public key is required to verify this signed QuadQR."
+  );
+
+  const publicKey = await normalizeEd25519PublicKey(trusted);
+  if (trustSource === "external" && parsed.publicKey.length) {
+    const trustedBytes = new Uint8Array(await subtle.exportKey("raw", publicKey));
+    assert(
+      trustedBytes.length === parsed.publicKey.length && trustedBytes.every((value, index) => value === parsed.publicKey[index]),
+      "Embedded signing key does not match the trusted public key."
+    );
+  }
+
+  const verified = await subtle.verify({ name: "Ed25519" }, publicKey, parsed.signature, parsed.signedBytes);
+  return {
+    verified,
+    trusted: verified && trustSource === "external",
+    trustSource,
+    keyId: parsed.keyId ?? null
+  };
+}
+
+function prepareOptionalCompressedPayload(input, compression = "none") {
+  const payload = asBytes(input);
+  const mode = normalizeCompressionMode(compression);
+  if (mode === "none") return { payload, extended: false, compression: "none" };
+  const prepared = prepareCompressedBody(payload, mode);
+  // Auto mode is truly zero-overhead when compression does not help.
+  if (mode === "auto" && prepared.compression === "none") {
+    return { payload, extended: false, compression: "none" };
+  }
+  return {
+    payload: packPayloadEnvelope(payload, { compression: prepared.compression }),
+    extended: true,
+    compression: prepared.compression
+  };
+}
+
 let CRC_TABLE = null;
 let CRC32_ACCELERATOR = null;
 
@@ -2397,8 +3281,19 @@ function crc32(bytes) {
   return (crc ^ 0xffffffff) >>> 0;
 }
 
-function bytesToCells(bytes) {
-  const out = new Array(bytes.length * CELLS_PER_BYTE);
+function bytesToCells(bytes, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
+  if (encoding === CELL_ENCODINGS.TRIANGLE16) {
+    const out = new Array(bytes.length * TRIANGLE16_CELLS_PER_BYTE);
+    let cursor = 0;
+    for (const byte of bytes) {
+      out[cursor++] = (byte >>> 4) & 0x0f;
+      out[cursor++] = byte & 0x0f;
+    }
+    return out;
+  }
+
+  const out = new Array(bytes.length * RGBW_CELLS_PER_BYTE);
   let cursor = 0;
   for (const byte of bytes) {
     out[cursor++] = (byte >>> 6) & 0b11;
@@ -2409,11 +3304,36 @@ function bytesToCells(bytes) {
   return out;
 }
 
-function cellsToBytes(cells, byteCount = Math.floor(cells.length / CELLS_PER_BYTE)) {
-  assert(cells.length >= byteCount * CELLS_PER_BYTE, "Not enough RGBW cells to rebuild bytes.");
-  const out = new Uint8Array(byteCount);
-  for (let i = 0; i < byteCount; i++) {
-    const offset = i * CELLS_PER_BYTE;
+function bytesToProtectedHeaderCells(bytes, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const base = bytesToCells(bytes, CELL_ENCODINGS.RGBW);
+  if (normalizeCellEncoding(cellEncoding) !== CELL_ENCODINGS.TRIANGLE16) return base;
+  // Triangle16 deliberately keeps the protected bootstrap/header as solid-color
+  // modules. This costs a few cells but makes mode detection and damaged-camera
+  // recovery substantially more reliable.
+  return base.map(solidTriangleCell);
+}
+
+function cellsToBytes(cells, byteCount, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
+  const cellsPerByte = cellsPerByteForEncoding(encoding);
+  const count = byteCount ?? Math.floor(cells.length / cellsPerByte);
+  assert(cells.length >= count * cellsPerByte, "Not enough data cells to rebuild bytes.");
+  const out = new Uint8Array(count);
+
+  if (encoding === CELL_ENCODINGS.TRIANGLE16) {
+    for (let i = 0; i < count; i++) {
+      const offset = i * TRIANGLE16_CELLS_PER_BYTE;
+      const a = cells[offset];
+      const b = cells[offset + 1];
+      assert(Number.isInteger(a) && a >= 0 && a <= 15, "Invalid Triangle16 data cell.");
+      assert(Number.isInteger(b) && b >= 0 && b <= 15, "Invalid Triangle16 data cell.");
+      out[i] = (a << 4) | b;
+    }
+    return out;
+  }
+
+  for (let i = 0; i < count; i++) {
+    const offset = i * RGBW_CELLS_PER_BYTE;
     const a = cells[offset];
     const b = cells[offset + 1];
     const c = cells[offset + 2];
@@ -2426,12 +3346,31 @@ function cellsToBytes(cells, byteCount = Math.floor(cells.length / CELLS_PER_BYT
   return out;
 }
 
-function flagsFor(text, eccLevel, secure = false) {
+function protectedHeaderCellsToBytes(cells, byteCount, cellEncoding = CELL_ENCODINGS.RGBW) {
+  if (normalizeCellEncoding(cellEncoding) !== CELL_ENCODINGS.TRIANGLE16) {
+    return cellsToBytes(cells, byteCount, CELL_ENCODINGS.RGBW);
+  }
+  const colors = cells.map((value) => {
+    const pair = unpackTriangleCell(value);
+    if (pair.first !== pair.second) throw new Error("Triangle16 protected header lost solid-color integrity.");
+    return pair.first;
+  });
+  return cellsToBytes(colors, byteCount, CELL_ENCODINGS.RGBW);
+}
+
+function flagsFor(text, eccLevel, secure = false, extended = false, signed = false, cellEncoding = CELL_ENCODINGS.RGBW) {
   return (text ? TEXT_FLAG : 0) |
     (secure ? SECURE_FLAG : 0) |
+    (extended ? EXTENDED_PAYLOAD_FLAG : 0) |
+    (signed ? SIGNED_FLAG : 0) |
+    (normalizeCellEncoding(cellEncoding) === CELL_ENCODINGS.TRIANGLE16 ? TRIANGLE16_FLAG : 0) |
     ((ECC_LEVELS[eccLevel].id << ECC_SHIFT) & ECC_MASK);
 }
 
+function cellEncodingFromFlags(flags) {
+  return (flags & TRIANGLE16_FLAG) !== 0 ? CELL_ENCODINGS.TRIANGLE16 : CELL_ENCODINGS.RGBW;
+}
+
 function eccFromFlags(flags) {
   const id = (flags & ECC_MASK) >> ECC_SHIFT;
   const name = ECC_BY_ID[id];
@@ -2681,7 +3620,8 @@ function maskValue(row, col, maskId) {
   }
 }
 
-function makePaddingCells(count, seed) {
+function makePaddingCells(count, seed, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
   let state = (seed >>> 0) || 0x6d2b79f5;
   const out = new Array(count);
   for (let i = 0; i < count; i++) {
@@ -2689,11 +3629,27 @@ function makePaddingCells(count, seed) {
     state ^= state >>> 17;
     state ^= state << 5;
     state >>>= 0;
-    out[i] = state & 3;
+    out[i] = encoding === CELL_ENCODINGS.TRIANGLE16 ? (state & 0x0f) : (state & 3);
   }
   return out;
 }
 
+function triangleMaskValue(row, col, maskId) {
+  const first = maskValue(row, col, maskId);
+  const second = maskValue(row + 1, col + 2, (maskId + 1) & 3);
+  return packTriangleCell(first, second);
+}
+
+function applyCellMask(value, row, col, maskId, cellEncoding, protectedHeader = false) {
+  if (cellEncoding !== CELL_ENCODINGS.TRIANGLE16) return value ^ maskValue(row, col, maskId);
+  if (protectedHeader) {
+    const pair = unpackTriangleCell(value);
+    if (pair.first !== pair.second) throw new Error("Triangle16 protected header must use solid-color cells.");
+    return solidTriangleCell(pair.first ^ maskValue(row, col, maskId));
+  }
+  return value ^ triangleMaskValue(row, col, maskId);
+}
+
 const SPECTRAL_PERMUTATION_CACHE = new Map();
 
 function spectralPermutation(length, version) {
@@ -2722,7 +3678,15 @@ function spectralPermutation(length, version) {
   return permutation;
 }
 
-function applyData(layout, rawCells, maskId, spectralInterleaving = true) {
+function applyData(
+  layout,
+  rawCells,
+  maskId,
+  spectralInterleaving = true,
+  cellEncoding = CELL_ENCODINGS.RGBW,
+  protectedHeaderCells = getHeaderPlan(layout.version).codewordCells
+) {
+  const encoding = normalizeCellEncoding(cellEncoding);
   const matrix = cloneMatrix(layout.matrix);
   const permutation = spectralInterleaving
     ? spectralPermutation(layout.dataPositions.length, layout.version)
@@ -2731,16 +3695,37 @@ function applyData(layout, rawCells, maskId, spectralInterleaving = true) {
   for (let logicalIndex = 0; logicalIndex < layout.dataPositions.length; logicalIndex++) {
     const physicalIndex = permutation ? permutation[logicalIndex] : logicalIndex;
     const [row, col] = layout.dataPositions[physicalIndex];
-    matrix[row][col] = rawCells[logicalIndex] ^ maskValue(row, col, maskId);
+    matrix[row][col] = applyCellMask(
+      rawCells[logicalIndex],
+      row,
+      col,
+      maskId,
+      encoding,
+      encoding === CELL_ENCODINGS.TRIANGLE16 && logicalIndex < protectedHeaderCells
+    );
   }
   return matrix;
 }
 
-function quaternaryPenalty(matrix, reserved) {
+function dataCellPenalty(matrix, reserved, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
   const size = matrix.length;
   let penalty = 0;
-  const counts = [0, 0, 0, 0];
-  let dataCount = 0;
+  const colorCounts = [0, 0, 0, 0];
+  let colorCount = 0;
+
+  const symbolAt = (r, c) => matrix[r][c];
+  const addColors = (value) => {
+    if (encoding === CELL_ENCODINGS.TRIANGLE16) {
+      const pair = unpackTriangleCell(value);
+      colorCounts[pair.first]++;
+      colorCounts[pair.second]++;
+      colorCount += 2;
+    } else {
+      colorCounts[value]++;
+      colorCount++;
+    }
+  };
 
   for (let r = 0; r < size; r++) {
     let previous = null;
@@ -2751,9 +3736,8 @@ function quaternaryPenalty(matrix, reserved) {
         run = 0;
         continue;
       }
-      const value = matrix[r][c];
-      counts[value]++;
-      dataCount++;
+      const value = symbolAt(r, c);
+      addColors(value);
       if (value === previous) {
         run++;
         if (run >= 4) penalty += 2;
@@ -2773,7 +3757,7 @@ function quaternaryPenalty(matrix, reserved) {
         run = 0;
         continue;
       }
-      const value = matrix[r][c];
+      const value = symbolAt(r, c);
       if (value === previous) {
         run++;
         if (run >= 4) penalty += 2;
@@ -2784,9 +3768,9 @@ function quaternaryPenalty(matrix, reserved) {
     }
   }
 
-  if (dataCount > 0) {
-    const ideal = dataCount / 4;
-    penalty += counts.reduce((sum, count) => sum + Math.abs(count - ideal), 0) / 2;
+  if (colorCount > 0) {
+    const ideal = colorCount / 4;
+    penalty += colorCounts.reduce((sum, count) => sum + Math.abs(count - ideal), 0) / 2;
   }
   return penalty;
 }
@@ -2815,7 +3799,7 @@ function deinterleaveBlocks(stream, blockLengths) {
   return blocks;
 }
 
-function getBodyRsPlan(payloadLength, eccLevel, version = 2) {
+function getBodyRsPlan(payloadLength, eccLevel, version = 2, cellEncoding = CELL_ENCODINGS.RGBW) {
   const ecc = getEffectiveEcc(version, eccLevel);
   const bodyByteCount = payloadLength + CRC_BYTES;
   const dataSymbols = bodyByteCount;
@@ -2837,25 +3821,27 @@ function getBodyRsPlan(payloadLength, eccLevel, version = 2) {
     dataBlockLengths,
     codewordBlockLengths,
     encodedSymbols,
-    encodedCells: encodedSymbols * CELLS_PER_BYTE
+    encodedCells: encodedSymbols * cellsPerByteForEncoding(cellEncoding)
   };
 }
 
-function streamCellCount(payloadLength, eccLevel, version) {
-  return getHeaderPlan(version).codewordCells + getBodyRsPlan(payloadLength, eccLevel, version).encodedCells;
+function streamCellCount(payloadLength, eccLevel, version, cellEncoding = CELL_ENCODINGS.RGBW) {
+  return getHeaderPlan(version).codewordCells +
+    getBodyRsPlan(payloadLength, eccLevel, version, cellEncoding).encodedCells;
 }
 
-function streamFitsLayout(layout, eccLevel, payloadLength, version) {
-  return streamCellCount(payloadLength, eccLevel, version) <= layout.dataPositions.length;
+function streamFitsLayout(layout, eccLevel, payloadLength, version, cellEncoding = CELL_ENCODINGS.RGBW) {
+  return streamCellCount(payloadLength, eccLevel, version, cellEncoding) <= layout.dataPositions.length;
 }
 
-function getCapacityForLayout(layout, eccLevel, version) {
-  if (!streamFitsLayout(layout, eccLevel, 0, version)) return 0;
+function getCapacityForLayout(layout, eccLevel, version, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
+  if (!streamFitsLayout(layout, eccLevel, 0, version, encoding)) return 0;
   let low = 0;
-  let high = Math.floor(layout.dataPositions.length / CELLS_PER_BYTE);
+  let high = Math.floor(layout.dataPositions.length / cellsPerByteForEncoding(encoding));
   while (low < high) {
     const mid = Math.ceil((low + high) / 2);
-    if (streamFitsLayout(layout, eccLevel, mid, version)) low = mid;
+    if (streamFitsLayout(layout, eccLevel, mid, version, encoding)) low = mid;
     else high = mid - 1;
   }
   return low;
@@ -2864,6 +3850,7 @@ function getCapacityForLayout(layout, eccLevel, version) {
 function getVersionInfo(version, options = {}) {
   validateVersion(version);
   const eccLevel = normalizeEccLevel(options.ecc ?? DEFAULT_ECC_LEVEL);
+  const cellEncoding = cellEncodingFromOptions(options);
   const layout = createLayout(version);
   const headerPlan = getHeaderPlan(version);
   const effectiveEcc = getEffectiveEcc(version, eccLevel);
@@ -2873,8 +3860,8 @@ function getVersionInfo(version, options = {}) {
     eccLevel,
     size: layout.size,
     dataCells: layout.dataPositions.length,
-    theoreticalBits: layout.dataPositions.length * 2,
-    capacityBytes: getCapacityForLayout(layout, eccLevel, version),
+    theoreticalBits: layout.dataPositions.length * (cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 4 : 2),
+    capacityBytes: getCapacityForLayout(layout, eccLevel, version, cellEncoding),
     headerCells: headerPlan.codewordCells,
     headerBytes: headerPlan.headerBytes,
     headerParitySymbols: headerPlan.paritySymbols,
@@ -2886,8 +3873,11 @@ function getVersionInfo(version, options = {}) {
     hasAlignmentMarker: true,
     alignmentPatterns: layout.alignments.length,
     alignmentCenters: layout.alignments.map(({ row, col }) => [row, col]),
-    bitsPerDataCell: 2,
+    bitsPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 4 : 2,
+    highDensity: cellEncoding === CELL_ENCODINGS.TRIANGLE16,
+    cellEncoding,
     colors: 4,
+    statesPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 16 : 4,
     spectralInterleaving: true,
     confidenceAwareEcc: true
   };
@@ -2898,6 +3888,7 @@ function chooseVersion(payloadLength, options = {}) {
   const minVersion = options.minVersion ?? MIN_VERSION;
   const maxVersion = options.maxVersion ?? MAX_VERSION;
   const ecc = normalizeEccLevel(options.ecc ?? DEFAULT_ECC_LEVEL);
+  const cellEncoding = cellEncodingFromOptions(options);
 
   validateVersion(minVersion);
   validateVersion(maxVersion);
@@ -2906,10 +3897,10 @@ function chooseVersion(payloadLength, options = {}) {
   if (requested !== "auto") {
     validateVersion(requested);
     assert(requested >= minVersion && requested <= maxVersion, "Requested version is outside selected bounds.");
-    const info = getVersionInfo(requested, { ecc });
+    const info = getVersionInfo(requested, { ecc, cellEncoding });
     const layout = createLayout(requested);
     assert(
-      payloadLength <= info.capacityBytes && streamFitsLayout(layout, ecc, payloadLength, requested),
+      payloadLength <= info.capacityBytes && streamFitsLayout(layout, ecc, payloadLength, requested, cellEncoding),
       `Payload does not fit version ${requested} with ${ecc} ECC. Maximum is ${info.capacityBytes} bytes.`
     );
     return requested;
@@ -2917,20 +3908,20 @@ function chooseVersion(payloadLength, options = {}) {
 
   for (let version = minVersion; version <= maxVersion; version++) {
     const layout = createLayout(version);
-    if (streamFitsLayout(layout, ecc, payloadLength, version)) return version;
+    if (streamFitsLayout(layout, ecc, payloadLength, version, cellEncoding)) return version;
   }
   throw new Error(`Payload is too large for versions ${minVersion}..${maxVersion}.`);
 }
 
-function encodeProtectedHeader(header, version) {
+function encodeProtectedHeader(header, version, cellEncoding = CELL_ENCODINGS.RGBW) {
   const plan = getHeaderPlan(version);
   const codeword = rsEncode(Array.from(header), plan.paritySymbols);
   assert(codeword.length === plan.codewordBytes, "Header RS symbol calculation mismatch.");
-  return bytesToCells(codeword);
+  return bytesToProtectedHeaderCells(codeword, cellEncoding);
 }
 
-function encodeProtectedBody(bodyBytes, eccLevel, version) {
-  const plan = getBodyRsPlan(bodyBytes.length - CRC_BYTES, eccLevel, version);
+function encodeProtectedBody(bodyBytes, eccLevel, version, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const plan = getBodyRsPlan(bodyBytes.length - CRC_BYTES, eccLevel, version, cellEncoding);
   assert(bodyBytes.length === plan.dataSymbols, "Body RS symbol calculation mismatch.");
 
   const blocks = [];
@@ -2939,7 +3930,7 @@ function encodeProtectedBody(bodyBytes, eccLevel, version) {
     blocks.push(rsEncode(Array.from(bodyBytes.slice(offset, offset + length)), plan.paritySymbols));
     offset += length;
   }
-  return { cells: bytesToCells(interleaveBlocks(blocks)), plan };
+  return { cells: bytesToCells(interleaveBlocks(blocks), cellEncoding), plan };
 }
 
 function finalizeMatrix(layout, rawCells, meta) {
@@ -2947,9 +3938,10 @@ function finalizeMatrix(layout, rawCells, meta) {
   let bestMatrix = null;
   let bestPenalty = Infinity;
 
+  const cellEncoding = normalizeCellEncoding(meta.cellEncoding ?? CELL_ENCODINGS.RGBW);
   for (let maskId = 0; maskId < 4; maskId++) {
-    const candidate = applyData(layout, rawCells, maskId, true);
-    const penalty = quaternaryPenalty(candidate, layout.reserved);
+    const candidate = applyData(layout, rawCells, maskId, true, cellEncoding);
+    const penalty = dataCellPenalty(candidate, layout.reserved, cellEncoding);
     if (penalty < bestPenalty) {
       bestPenalty = penalty;
       bestMaskId = maskId;
@@ -2957,7 +3949,7 @@ function finalizeMatrix(layout, rawCells, meta) {
     }
   }
 
-  const info = getVersionInfo(meta.version, { ecc: meta.eccLevel });
+  const info = getVersionInfo(meta.version, { ecc: meta.eccLevel, cellEncoding });
   return {
     format: "QuadQR",
     formatVersion: FORMAT_VERSION,
@@ -2968,6 +3960,11 @@ function finalizeMatrix(layout, rawCells, meta) {
     payloadBytes: meta.payloadBytes,
     sourcePayloadBytes: meta.sourcePayloadBytes ?? meta.payloadBytes,
     secure: Boolean(meta.secure),
+    compressed: meta.compression != null && meta.compression !== "none",
+    compression: meta.compression ?? "none",
+    signed: Boolean(meta.signed),
+    signingKeyId: meta.signingKeyId ?? null,
+    hasEmbeddedPublicKey: Boolean(meta.hasEmbeddedPublicKey),
     requiresDecryption: Boolean(meta.secure),
     security: meta.security ?? null,
     meaningfulCells: meta.meaningfulCells,
@@ -2975,7 +3972,10 @@ function finalizeMatrix(layout, rawCells, meta) {
     capacityBytes: info.capacityBytes,
     alignmentPatterns: layout.alignments.length,
     utilization: meta.meaningfulCells / layout.dataPositions.length,
-    bitsPerDataCell: 2,
+    bitsPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 4 : 2,
+    highDensity: cellEncoding === CELL_ENCODINGS.TRIANGLE16,
+    cellEncoding,
+    statesPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 16 : 4,
     eccLevel: meta.eccLevel,
     eccParitySymbols: meta.eccParitySymbols,
     eccBlocks: meta.eccBlocks,
@@ -2986,39 +3986,44 @@ function finalizeMatrix(layout, rawCells, meta) {
   };
 }
 
-function encodeText(text, options = {}) {
-  assert(typeof text === "string", "encodeText expects a string.");
-  return encodeBytes(getTextEncoder().encode(text), { ...options, text: true });
-}
-
-function encodeBytes(input, options = {}) {
+function encodePreparedBytes(input, options = {}) {
   if (options.formatVersion != null && options.formatVersion !== FORMAT_VERSION) {
     throw new Error(`Only QuadQR format version ${FORMAT_VERSION} is supported.`);
   }
 
-  const payload = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const payload = asBytes(input);
   const eccLevel = normalizeEccLevel(options.ecc ?? DEFAULT_ECC_LEVEL);
   const secure = Boolean(options.secure);
-  const flags = flagsFor(Boolean(options.text), eccLevel, secure);
-  const version = chooseVersion(payload.length, { ...options, ecc: eccLevel });
+  const extended = Boolean(options.extended);
+  const signed = Boolean(options.signed);
+  const cellEncoding = cellEncodingFromOptions(options);
+  const flags = flagsFor(Boolean(options.text), eccLevel, secure, extended, signed, cellEncoding);
+  const version = chooseVersion(payload.length, { ...options, ecc: eccLevel, cellEncoding });
   const layout = createLayout(version);
   const header = makeHeader(payload.length, flags, version);
   const crc = crc32(concatBytes(header, payload));
-  const headerCells = encodeProtectedHeader(header, version);
-  const bodyEncoded = encodeProtectedBody(concatBytes(payload, u32be(crc)), eccLevel, version);
+  const headerCells = encodeProtectedHeader(header, version, cellEncoding);
+  const bodyEncoded = encodeProtectedBody(concatBytes(payload, u32be(crc)), eccLevel, version, cellEncoding);
   const meaningfulCells = headerCells.concat(bodyEncoded.cells);
   assert(meaningfulCells.length <= layout.dataPositions.length, "Internal QuadQR capacity calculation error.");
 
   const padding = makePaddingCells(
     layout.dataPositions.length - meaningfulCells.length,
-    crc ^ payload.length ^ (version << 24) ^ (ECC_LEVELS[eccLevel].id << 16)
+    crc ^ payload.length ^ (version << 24) ^ (ECC_LEVELS[eccLevel].id << 16),
+    cellEncoding
   );
 
   return finalizeMatrix(layout, meaningfulCells.concat(padding), {
     version,
+    cellEncoding,
     payloadBytes: payload.length,
     sourcePayloadBytes: options.sourcePayloadBytes ?? payload.length,
     secure,
+    extended,
+    signed,
+    compression: options.compressionMetadata ?? "none",
+    signingKeyId: options.signingKeyId ?? null,
+    hasEmbeddedPublicKey: Boolean(options.hasEmbeddedPublicKey),
     security: options.securityMetadata ?? null,
     meaningfulCells: meaningfulCells.length,
     eccLevel,
@@ -3029,6 +4034,58 @@ function encodeBytes(input, options = {}) {
   });
 }
 
+function encodeText(text, options = {}) {
+  assert(typeof text === "string", "encodeText expects a string.");
+  const source = getTextEncoder().encode(text);
+  const prepared = prepareOptionalCompressedPayload(source, options.compression ?? "none");
+  return encodePreparedBytes(prepared.payload, {
+    ...options,
+    text: true,
+    extended: prepared.extended,
+    sourcePayloadBytes: source.length,
+    compressionMetadata: prepared.compression
+  });
+}
+
+function encodeBytes(input, options = {}) {
+  const source = asBytes(input);
+  const prepared = prepareOptionalCompressedPayload(source, options.compression ?? "none");
+  return encodePreparedBytes(prepared.payload, {
+    ...options,
+    text: Boolean(options.text),
+    extended: prepared.extended,
+    sourcePayloadBytes: source.length,
+    compressionMetadata: prepared.compression
+  });
+}
+
+/** Explicit Uint8Array convenience API. Equivalent to encodeBytes(). */
+function encodeUint8Array(input, options = {}) {
+  return encodeBytes(asBytes(input), options);
+}
+
+/** Encode and sign a normal payload using an internal Ed25519 envelope. */
+async function encodeSignedBytes(input, options = {}) {
+  const source = asBytes(input);
+  const envelope = await packSignedPayloadEnvelope(source, options);
+  const parsed = parsePayloadEnvelope(envelope);
+  return encodePreparedBytes(envelope, {
+    ...options,
+    text: Boolean(options.text),
+    extended: true,
+    signed: true,
+    sourcePayloadBytes: source.length,
+    compressionMetadata: parsed.compression,
+    signingKeyId: parsed.keyId,
+    hasEmbeddedPublicKey: parsed.hasEmbeddedPublicKey
+  });
+}
+
+async function encodeSignedText(text, options = {}) {
+  assert(typeof text === "string", "encodeSignedText expects a string.");
+  return encodeSignedBytes(getTextEncoder().encode(text), { ...options, text: true });
+}
+
 /**
  * Encode text using the optional QuadQR Secure Payload v1 layer.
  * This API is async because Web Crypto performs AES-GCM and password KDF work asynchronously.
@@ -3040,32 +4097,75 @@ async function encodeSecureText(text, options = {}) {
 
 /** Encode arbitrary bytes using password or raw 256-bit key security. */
 async function encodeSecureBytes(input, options = {}) {
-  const sourcePayload = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const sourcePayload = asBytes(input);
   const security = options.security ?? {};
-  const encrypted = await encryptSecurePayload(sourcePayload, security);
-  return encodeBytes(encrypted.envelope, {
+  let protectedPayload = sourcePayload;
+  let extended = false;
+  let signed = false;
+  let compression = "none";
+  let signingKeyId = null;
+  let hasEmbeddedPublicKey = false;
+
+  if (options.signing) {
+    protectedPayload = await packSignedPayloadEnvelope(sourcePayload, {
+      ...options,
+      ...options.signing,
+      compression: options.compression ?? "auto"
+    });
+    const parsed = parsePayloadEnvelope(protectedPayload);
+    extended = true;
+    signed = true;
+    compression = parsed.compression;
+    signingKeyId = parsed.keyId;
+    hasEmbeddedPublicKey = parsed.hasEmbeddedPublicKey;
+  } else {
+    const prepared = prepareOptionalCompressedPayload(sourcePayload, options.compression ?? "none");
+    protectedPayload = prepared.payload;
+    extended = prepared.extended;
+    compression = prepared.compression;
+  }
+
+  const encrypted = await encryptSecurePayload(protectedPayload, security);
+  return encodePreparedBytes(encrypted.envelope, {
     ...options,
     text: Boolean(options.text),
     secure: true,
+    extended,
+    signed,
     sourcePayloadBytes: sourcePayload.length,
+    compressionMetadata: compression,
+    signingKeyId,
+    hasEmbeddedPublicKey,
     securityMetadata: encrypted.metadata
   });
 }
 
 /**
  * Decrypt a result returned by decodeMatrix/scanImageData/scanFile.
- * The encrypted envelope remains available as encryptedPayload.
+ * Compression and signatures are automatically unwrapped after decryption.
  */
 async function decryptDecoded(result, security = {}) {
   assert(result?.secure && result?.payload, "decryptDecoded expects an encrypted QuadQR decode result.");
   const plaintext = await decryptSecurePayload(result.payload, security);
   const isText = (result.flags & TEXT_FLAG) !== 0;
+  const extended = (result.flags & EXTENDED_PAYLOAD_FLAG) !== 0;
+  const envelope = extended ? parsePayloadEnvelope(plaintext) : null;
+  const payload = envelope ? envelope.payload : plaintext;
   return {
     ...result,
     encryptedPayload: result.payload,
     encryptedPayloadBytes: result.payload.length,
-    payload: plaintext,
-    text: isText ? getTextDecoder().decode(plaintext) : null,
+    protectedPayload: envelope ? plaintext : undefined,
+    payload,
+    text: isText ? getTextDecoder().decode(payload) : null,
+    compressed: envelope?.compressed ?? false,
+    compression: envelope?.compression ?? "none",
+    signed: envelope?.signed ?? result.signed ?? false,
+    signatureVerified: envelope?.signatureVerified ?? result.signatureVerified,
+    signatureTrusted: envelope?.signatureTrusted ?? result.signatureTrusted,
+    signingKeyId: envelope?.keyId ?? result.signingKeyId ?? null,
+    hasEmbeddedPublicKey: envelope?.hasEmbeddedPublicKey ?? result.hasEmbeddedPublicKey ?? false,
+    signer: envelope?.signer ?? result.signer ?? null,
     decrypted: true,
     requiresDecryption: false,
     security: { ...result.security, decrypted: true }
@@ -3145,12 +4245,14 @@ function rotate90(matrix) {
   return out;
 }
 
-function extractVisibleCells(matrix, layout) {
+function extractVisibleCells(matrix, layout, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const encoding = normalizeCellEncoding(cellEncoding);
+  const maxValue = encoding === CELL_ENCODINGS.TRIANGLE16 ? 15 : 3;
   const out = [];
   for (const [row, col] of layout.dataPositions) {
     const value = matrix[row][col];
-    if (!Number.isInteger(value) || value < 0 || value > 3) {
-      throw new Error("Data region contains an invalid QuadQR data cell.");
+    if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+      throw new Error(`Data region contains an invalid ${encoding === CELL_ENCODINGS.TRIANGLE16 ? "Triangle16" : "RGBW"} data cell.`);
     }
     out.push(value);
   }
@@ -3164,6 +4266,34 @@ function unmaskCells(visibleCells, positions, maskId) {
   });
 }
 
+function unmaskAndRestoreLogicalCells(
+  visibleCells,
+  positions,
+  maskId,
+  version,
+  spectralInterleaving,
+  cellEncoding = CELL_ENCODINGS.RGBW
+) {
+  const encoding = normalizeCellEncoding(cellEncoding);
+  const permutation = spectralInterleaving ? spectralPermutation(visibleCells.length, version) : null;
+  const logical = new Array(visibleCells.length);
+  const headerCells = getHeaderPlan(version).codewordCells;
+
+  for (let logicalIndex = 0; logicalIndex < visibleCells.length; logicalIndex++) {
+    const physicalIndex = permutation ? permutation[logicalIndex] : logicalIndex;
+    const [row, col] = positions[physicalIndex];
+    logical[logicalIndex] = applyCellMask(
+      visibleCells[physicalIndex],
+      row,
+      col,
+      maskId,
+      encoding,
+      encoding === CELL_ENCODINGS.TRIANGLE16 && logicalIndex < headerCells
+    );
+  }
+  return logical;
+}
+
 function restoreLogicalOrder(physicalValues, version, spectralInterleaving) {
   if (!spectralInterleaving) return physicalValues.slice();
   const permutation = spectralPermutation(physicalValues.length, version);
@@ -3174,20 +4304,21 @@ function restoreLogicalOrder(physicalValues, version, spectralInterleaving) {
   return logical;
 }
 
-function cellsToSymbolConfidences(confidences, byteCount) {
+function cellsToSymbolConfidences(
+  confidences,
+  byteCount,
+  cellsPerByte = RGBW_CELLS_PER_BYTE
+) {
   if (!confidences) return null;
-  if (confidences.length < byteCount * CELLS_PER_BYTE) return null;
+  if (confidences.length < byteCount * cellsPerByte) return null;
   const out = new Array(byteCount);
   for (let symbolIndex = 0; symbolIndex < byteCount; symbolIndex++) {
-    const offset = symbolIndex * CELLS_PER_BYTE;
-    // A single wrong 2-bit cell changes the GF(256) symbol, so the weakest
-    // constituent cell is the useful confidence bound for that symbol.
-    out[symbolIndex] = Math.min(
-      confidences[offset] ?? 1,
-      confidences[offset + 1] ?? 1,
-      confidences[offset + 2] ?? 1,
-      confidences[offset + 3] ?? 1
-    );
+    const offset = symbolIndex * cellsPerByte;
+    let value = 1;
+    for (let cellIndex = 0; cellIndex < cellsPerByte; cellIndex++) {
+      value = Math.min(value, confidences[offset + cellIndex] ?? 1);
+    }
+    out[symbolIndex] = value;
   }
   return out;
 }
@@ -3224,11 +4355,11 @@ function decodeRsAdaptive(codeword, paritySymbols, symbolConfidences, options =
   }
 }
 
-function decodeProtectedHeader(rawCells, version, rawConfidences = null, options = {}) {
+function decodeProtectedHeader(rawCells, version, rawConfidences = null, options = {}, cellEncoding = CELL_ENCODINGS.RGBW) {
   const plan = getHeaderPlan(version);
   const headerCells = rawCells.slice(0, plan.codewordCells);
-  const codeword = Array.from(cellsToBytes(headerCells, plan.codewordBytes));
-  const confidences = cellsToSymbolConfidences(rawConfidences?.slice(0, plan.codewordCells), plan.codewordBytes);
+  const codeword = Array.from(protectedHeaderCellsToBytes(headerCells, plan.codewordBytes, cellEncoding));
+  const confidences = cellsToSymbolConfidences(rawConfidences?.slice(0, plan.codewordCells), plan.codewordBytes, RGBW_CELLS_PER_BYTE);
   const decoded = decodeRsAdaptive(codeword, plan.paritySymbols, confidences, options);
   const header = new Uint8Array(decoded.data);
   const parsed = parseHeader(header, version);
@@ -3243,16 +4374,17 @@ function decodeProtectedHeader(rawCells, version, rawConfidences = null, options
   };
 }
 
-function decodeProtectedBody(rawCells, payloadLength, eccLevel, version, rawConfidences = null, options = {}) {
-  const plan = getBodyRsPlan(payloadLength, eccLevel, version);
+function decodeProtectedBody(rawCells, payloadLength, eccLevel, version, rawConfidences = null, options = {}, cellEncoding = CELL_ENCODINGS.RGBW) {
+  const plan = getBodyRsPlan(payloadLength, eccLevel, version, cellEncoding);
   const bodyStart = getHeaderPlan(version).codewordCells;
   const encodedCells = rawCells.slice(bodyStart, bodyStart + plan.encodedCells);
   if (encodedCells.length !== plan.encodedCells) throw new Error("Protected body is incomplete.");
 
-  const encodedSymbols = Array.from(cellsToBytes(encodedCells, plan.encodedSymbols));
+  const encodedSymbols = Array.from(cellsToBytes(encodedCells, plan.encodedSymbols, cellEncoding));
   const symbolConfidences = cellsToSymbolConfidences(
     rawConfidences?.slice(bodyStart, bodyStart + plan.encodedCells),
-    plan.encodedSymbols
+    plan.encodedSymbols,
+    cellsPerByteForEncoding(cellEncoding)
   );
   const blocks = deinterleaveBlocks(encodedSymbols, plan.codewordBlockLengths);
   const confidenceBlocks = symbolConfidences
@@ -3295,83 +4427,136 @@ function decodeCanonical(matrix, rotation, tolerance = 0, confidenceMatrix = nul
   if (!validateStructure(matrix, tolerance)) throw new Error("QuadQR finder/alignment structure does not match.");
 
   const layout = createLayout(version);
-  const visible = extractVisibleCells(matrix, layout);
-  const visibleConfidences = confidenceMatrix
-    ? layout.dataPositions.map(([row, col]) => confidenceMatrix[row]?.[col] ?? 1)
-    : null;
   const errors = [];
+  const hintedEncoding = options.cellEncodingHint != null
+    ? normalizeCellEncoding(options.cellEncodingHint)
+    : null;
+  const hasExtendedCells = layout.dataPositions.some(([row, col]) => (matrix[row]?.[col] ?? 0) > 3);
+  const encodingAttempts = hintedEncoding
+    ? [hintedEncoding]
+    : hasExtendedCells
+      ? [CELL_ENCODINGS.TRIANGLE16, CELL_ENCODINGS.RGBW]
+      : [CELL_ENCODINGS.RGBW, CELL_ENCODINGS.TRIANGLE16];
+
+  for (const cellEncoding of encodingAttempts) {
+    let visible;
+    try {
+      visible = extractVisibleCells(matrix, layout, cellEncoding);
+    } catch (error) {
+      errors.push(`${cellEncoding}: ${error.message}`);
+      continue;
+    }
 
-  // New symbols use spectral-spatial interleaving. Legacy order remains a
-  // decode fallback so existing QuadQR images do not become unreadable.
-  for (const spectralInterleaving of [true, false]) {
-    for (let maskId = 0; maskId < 4; maskId++) {
-      try {
-        const physicalRaw = unmaskCells(visible, layout.dataPositions, maskId);
-        const raw = restoreLogicalOrder(physicalRaw, version, spectralInterleaving);
-        const rawConfidences = visibleConfidences
-          ? restoreLogicalOrder(visibleConfidences, version, spectralInterleaving)
-          : null;
-        const headerDecoded = decodeProtectedHeader(raw, version, rawConfidences, options);
-        const header = headerDecoded.header;
-        const flags = headerDecoded.flags;
-        const eccLevel = eccFromFlags(flags);
-        const payloadLength = headerDecoded.payloadLength;
-        if (streamCellCount(payloadLength, eccLevel, version) > raw.length) {
-          throw new Error("Declared payload exceeds matrix capacity.");
-        }
+    const visibleConfidences = confidenceMatrix
+      ? layout.dataPositions.map(([row, col]) => confidenceMatrix[row]?.[col] ?? 1)
+      : null;
 
-        const bodyDecoded = decodeProtectedBody(
-          raw,
-          payloadLength,
-          eccLevel,
-          version,
-          rawConfidences,
-          options
-        );
-        const body = bodyDecoded.body;
-        const payload = body.slice(0, payloadLength);
-        const expectedCrc = readU32be(body, payloadLength);
-        const actualCrc = crc32(concatBytes(header, payload));
-        if (expectedCrc !== actualCrc) throw new Error("CRC mismatch after ECC.");
-
-        const isText = (flags & TEXT_FLAG) !== 0;
-        const secure = (flags & SECURE_FLAG) !== 0;
-        const security = secure ? inspectSecureEnvelope(payload) : null;
-        const erasureSymbols = headerDecoded.erasureSymbols + bodyDecoded.erasureSymbols;
-        const unknownErrorSymbols = headerDecoded.unknownErrorSymbols + bodyDecoded.unknownErrorSymbols;
-        return {
-          ok: true,
-          format: "QuadQR",
-          formatVersion: FORMAT_VERSION,
-          version,
-          size,
-          alignmentPatterns: layout.alignments.length,
-          maskId,
-          rotation,
-          flags,
-          eccLevel,
-          eccParitySymbols: bodyDecoded.plan.paritySymbols,
-          eccBlocks: bodyDecoded.plan.dataBlockLengths.length,
-          correctableSymbolsPerBlock: bodyDecoded.plan.correctableSymbolsPerBlock,
-          spectralInterleaving,
-          confidenceAwareEcc: Boolean(rawConfidences),
-          confidenceAssisted: headerDecoded.confidenceAssisted || bodyDecoded.confidenceAssisted,
-          erasureSymbols,
-          unknownErrorSymbols,
-          correctedHeaderSymbols: headerDecoded.correctedSymbols,
-          correctedBodySymbols: bodyDecoded.correctedSymbols,
-          correctedSymbols: headerDecoded.correctedSymbols + bodyDecoded.correctedSymbols,
-          payload,
-          text: isText && !secure ? getTextDecoder().decode(payload) : null,
-          secure,
-          encrypted: secure,
-          decrypted: false,
-          requiresDecryption: secure,
-          security,
-          crc32: actualCrc >>> 0
-        };
-      } catch (error) {
-        errors.push(`${spectralInterleaving ? "spectral" : "legacy"} mask ${maskId}: ${error.message}`);
+    // New symbols use spectral-spatial interleaving. Legacy order remains a
+    // decode fallback so existing RGBW QuadQR images do not become unreadable.
+    for (const spectralInterleaving of [true, false]) {
+      for (let maskId = 0; maskId < 4; maskId++) {
+        try {
+          const raw = unmaskAndRestoreLogicalCells(
+            visible,
+            layout.dataPositions,
+            maskId,
+            version,
+            spectralInterleaving,
+            cellEncoding
+          );
+          const rawConfidences = visibleConfidences
+            ? restoreLogicalOrder(visibleConfidences, version, spectralInterleaving)
+            : null;
+          const headerDecoded = decodeProtectedHeader(
+            raw,
+            version,
+            rawConfidences,
+            options,
+            cellEncoding
+          );
+          const header = headerDecoded.header;
+          const flags = headerDecoded.flags;
+          const declaredCellEncoding = cellEncodingFromFlags(flags);
+          if (declaredCellEncoding !== cellEncoding) {
+            throw new Error(`Header declares ${declaredCellEncoding}, not ${cellEncoding}.`);
+          }
+          const eccLevel = eccFromFlags(flags);
+          const payloadLength = headerDecoded.payloadLength;
+          if (streamCellCount(payloadLength, eccLevel, version, cellEncoding) > raw.length) {
+            throw new Error("Declared payload exceeds matrix capacity.");
+          }
+
+          const bodyDecoded = decodeProtectedBody(
+            raw,
+            payloadLength,
+            eccLevel,
+            version,
+            rawConfidences,
+            options,
+            cellEncoding
+          );
+          const body = bodyDecoded.body;
+          const payload = body.slice(0, payloadLength);
+          const expectedCrc = readU32be(body, payloadLength);
+          const actualCrc = crc32(concatBytes(header, payload));
+          if (expectedCrc !== actualCrc) throw new Error("CRC mismatch after ECC.");
+
+          const isText = (flags & TEXT_FLAG) !== 0;
+          const secure = (flags & SECURE_FLAG) !== 0;
+          const extendedFlag = (flags & EXTENDED_PAYLOAD_FLAG) !== 0;
+          const signedFlag = (flags & SIGNED_FLAG) !== 0;
+          const security = secure ? inspectSecureEnvelope(payload) : null;
+          const envelope = extendedFlag && !secure ? parsePayloadEnvelope(payload) : null;
+          const applicationPayload = envelope ? envelope.payload : payload;
+          const erasureSymbols = headerDecoded.erasureSymbols + bodyDecoded.erasureSymbols;
+          const unknownErrorSymbols = headerDecoded.unknownErrorSymbols + bodyDecoded.unknownErrorSymbols;
+          return {
+            ok: true,
+            format: "QuadQR",
+            formatVersion: FORMAT_VERSION,
+            version,
+            size,
+            alignmentPatterns: layout.alignments.length,
+            maskId,
+            rotation,
+            flags,
+            highDensity: cellEncoding === CELL_ENCODINGS.TRIANGLE16,
+            cellEncoding,
+            bitsPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 4 : 2,
+            statesPerDataCell: cellEncoding === CELL_ENCODINGS.TRIANGLE16 ? 16 : 4,
+            eccLevel,
+            eccParitySymbols: bodyDecoded.plan.paritySymbols,
+            eccBlocks: bodyDecoded.plan.dataBlockLengths.length,
+            correctableSymbolsPerBlock: bodyDecoded.plan.correctableSymbolsPerBlock,
+            spectralInterleaving,
+            confidenceAwareEcc: Boolean(rawConfidences),
+            confidenceAssisted: headerDecoded.confidenceAssisted || bodyDecoded.confidenceAssisted,
+            erasureSymbols,
+            unknownErrorSymbols,
+            correctedHeaderSymbols: headerDecoded.correctedSymbols,
+            correctedBodySymbols: bodyDecoded.correctedSymbols,
+            correctedSymbols: headerDecoded.correctedSymbols + bodyDecoded.correctedSymbols,
+            protectedPayload: envelope ? payload : undefined,
+            payload: secure ? payload : applicationPayload,
+            text: secure ? null : (isText ? getTextDecoder().decode(applicationPayload) : null),
+            compressed: envelope?.compressed ?? false,
+            compression: envelope?.compression ?? "none",
+            signed: envelope?.signed ?? signedFlag,
+            signatureVerified: envelope?.signatureVerified,
+            signatureTrusted: envelope?.signatureTrusted,
+            signingKeyId: envelope?.keyId ?? null,
+            hasEmbeddedPublicKey: envelope?.hasEmbeddedPublicKey ?? false,
+            signer: envelope?.signer ?? null,
+            secure,
+            encrypted: secure,
+            decrypted: false,
+            requiresDecryption: secure,
+            security,
+            crc32: actualCrc >>> 0
+          };
+        } catch (error) {
+          errors.push(`${cellEncoding} ${spectralInterleaving ? "spectral" : "legacy"} mask ${maskId}: ${error.message}`);
+        }
       }
     }
   }
@@ -3407,6 +4592,26 @@ function decodeMatrix(inputMatrix, options = {}) {
   throw new Error(`Unable to decode matrix. ${errors.join(" || ")}`);
 }
 
+/** Decode a matrix and return only its application payload bytes. */
+function decodeUint8Array(inputMatrix, options = {}) {
+  return decodeMatrix(inputMatrix, options).payload;
+}
+
+/** Verify a signed decode result and return the result with verification state attached. */
+async function verifyDecodedSignature(result, options = {}) {
+  assert(result?.signed, "Decode result is not signed.");
+  const source = result.protectedPayload;
+  assert(source, "Signed payload metadata is unavailable. Decrypt secure content first if necessary.");
+  const verification = await verifyPayloadEnvelopeSignature(source, options);
+  return {
+    ...result,
+    signatureVerified: verification.verified,
+    signatureTrusted: verification.trusted,
+    signingKeyId: verification.keyId ?? result.signingKeyId ?? null,
+    signatureTrustSource: verification.trustSource
+  };
+}
+
 function hexToRgb(hex) {
   const clean = hex.replace("#", "");
   assert(clean.length === 6, `Invalid hex color ${hex}.`);
@@ -3421,6 +4626,18 @@ function resolvePalette(palette = {}) {
   return { ...DEFAULT_PALETTE, ...palette };
 }
 
+function normalizeRenderMode(mode = RENDER_MODES.SCREEN) {
+  const value = String(mode).toLowerCase();
+  assert(value === RENDER_MODES.SCREEN || value === RENDER_MODES.PRINT, "Render mode must be screen or print.");
+  return value;
+}
+
+function resolveRenderPalette(options = {}) {
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const base = mode === RENDER_MODES.PRINT ? PRINT_PALETTE : DEFAULT_PALETTE;
+  return { ...base, ...(options.palette ?? {}) };
+}
+
 function paletteRgb(palette = {}) {
   const p = resolvePalette(palette);
   return {
@@ -3454,6 +4671,79 @@ function cellRgb(cell, palette) {
   }
 }
 
+function inferCellEncoding(codeOrMatrix, matrix, layout = null) {
+  if (!Array.isArray(codeOrMatrix) && codeOrMatrix?.cellEncoding) {
+    return normalizeCellEncoding(codeOrMatrix.cellEncoding);
+  }
+  const activeLayout = layout ?? renderLayoutForMatrix(matrix);
+  if (activeLayout) {
+    for (const [row, col] of activeLayout.dataPositions) {
+      if ((matrix[row]?.[col] ?? 0) > 3) return CELL_ENCODINGS.TRIANGLE16;
+    }
+  }
+  return CELL_ENCODINGS.RGBW;
+}
+
+function triangleCellColors(cell) {
+  const { first, second } = unpackTriangleCell(cell);
+  return { first, second };
+}
+
+function drawTriangleCellCanvas(ctx, x, y, width, height, cell, palette) {
+  const pair = triangleCellColors(cell);
+  if (pair.first === pair.second) {
+    ctx.fillStyle = cellColor(pair.first, palette);
+    ctx.fillRect(x, y, width, height);
+    return;
+  }
+
+  // Fixed "/" split. first = upper-left triangle, second = lower-right.
+  ctx.beginPath();
+  ctx.moveTo(x, y);
+  ctx.lineTo(x + width, y);
+  ctx.lineTo(x, y + height);
+  ctx.closePath();
+  ctx.fillStyle = cellColor(pair.first, palette);
+  ctx.fill();
+
+  ctx.beginPath();
+  ctx.moveTo(x + width, y);
+  ctx.lineTo(x + width, y + height);
+  ctx.lineTo(x, y + height);
+  ctx.closePath();
+  ctx.fillStyle = cellColor(pair.second, palette);
+  ctx.fill();
+}
+
+function fillImageTriangleCell(data, imageWidth, x, y, width, height, cell, palette) {
+  const pair = triangleCellColors(cell);
+  const firstRgb = cellRgb(pair.first, palette);
+  const secondRgb = cellRgb(pair.second, palette);
+  for (let yy = 0; yy < height; yy++) {
+    for (let xx = 0; xx < width; xx++) {
+      const normalizedX = (xx + 0.5) / Math.max(1, width);
+      const normalizedY = (yy + 0.5) / Math.max(1, height);
+      const rgb = normalizedX + normalizedY <= 1 ? firstRgb : secondRgb;
+      const p = ((y + yy) * imageWidth + (x + xx)) * 4;
+      data[p] = rgb.r;
+      data[p + 1] = rgb.g;
+      data[p + 2] = rgb.b;
+      data[p + 3] = 255;
+    }
+  }
+}
+
+function svgTriangleCell(x, y, size, cell, palette) {
+  const pair = triangleCellColors(cell);
+  if (pair.first === pair.second) return svgRect(x, y, size, size, cellColor(pair.first, palette));
+  const first = cellColor(pair.first, palette);
+  const second = cellColor(pair.second, palette);
+  return [
+    `<polygon points="${x},${y} ${x + size},${y} ${x},${y + size}" fill="${first}"/>`,
+    `<polygon points="${x + size},${y} ${x + size},${y + size} ${x},${y + size}" fill="${second}"/>`
+  ].join("");
+}
+
 function normalizeRenderStyle(style = RENDER_STYLES.CLASSIC) {
   const value = String(style).toLowerCase();
   const allowed = Object.values(RENDER_STYLES);
@@ -3584,18 +4874,347 @@ function fillImageRoundedRect(data, width, x, y, rectWidth, rectHeight, radius,
   }
 }
 
+/** Estimate a conservative center-logo ratio from ECC, utilization and output mode. */
+function estimateSafeLogoSize(codeOrMatrix, options = {}) {
+  const code = Array.isArray(codeOrMatrix) ? null : codeOrMatrix;
+  const ecc = String(code?.eccLevel ?? options.ecc ?? DEFAULT_ECC_LEVEL).toUpperCase();
+  const base = { L: 0.10, M: 0.13, Q: 0.16, H: 0.19 }[ecc] ?? 0.12;
+  const utilization = Number.isFinite(code?.utilization) ? code.utilization : Number(options.utilization ?? 0.65);
+  const utilizationPenalty = utilization <= 0.55 ? 1 : Math.max(0.72, 1 - (utilization - 0.55) * 0.56);
+  const clearBackground = Boolean(options.clearBackground ?? options.logoClearBackground ?? options.logo?.clearBackground);
+  const clearPenalty = clearBackground ? 0.90 : 1;
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const printPenalty = mode === RENDER_MODES.PRINT ? 0.88 : 1;
+  const versionPenalty = code?.version === 1 ? 0.88 : 1;
+  return Math.max(0.07, Math.min(0.22, base * utilizationPenalty * clearPenalty * printPenalty * versionPenalty));
+}
+
+/**
+ * Empirically search for the largest logo ratio that still decodes from the
+ * dependency-free ImageData renderer. The logo source must therefore be ImageData-like.
+ */
+function findMaxSafeLogoSize(code, options = {}) {
+  assert(code?.matrix, "findMaxSafeLogoSize expects an encoded QuadQR object.");
+  const logo = options.logo;
+  const source = logo?.source ?? logo;
+  assert(source?.data && source?.width && source?.height,
+    "findMaxSafeLogoSize requires an ImageData-like logo source so it can test pixel output without DOM dependencies.");
+  let low = Math.max(0.05, Number(options.minSize ?? 0.05));
+  let high = Math.min(0.30, Number(options.maxSize ?? 0.28));
+  let best = 0;
+  const iterations = Math.max(3, Math.min(10, Math.floor(options.iterations ?? 7)));
+  for (let i = 0; i < iterations; i++) {
+    const probe = (low + high) / 2;
+    try {
+      const image = renderToImageData(code, {
+        ...options,
+        logo: {
+          ...(typeof logo === "object" && Object.prototype.hasOwnProperty.call(logo, "source") ? logo : { source }),
+          size: probe
+        }
+      });
+      const decoded = scanImageData(image, { minVersion: code.version, maxVersion: code.version });
+      if (decoded.crc32 !== code.crc32) throw new Error("Decoded a different payload.");
+      best = probe;
+      low = probe;
+    } catch {
+      high = probe;
+    }
+  }
+  return {
+    safeSize: best || estimateSafeLogoSize(code, options),
+    testedMax: Number(options.maxSize ?? 0.28),
+    iterations,
+    empirical: best > 0
+  };
+}
+
+function getPrintGuidance(codeOrMatrix, options = {}) {
+  const matrix = Array.isArray(codeOrMatrix) ? codeOrMatrix : codeOrMatrix?.matrix;
+  assert(matrix?.length, "getPrintGuidance expects a QuadQR code or matrix.");
+  const quietZone = Math.max(4, Math.floor(options.quietZone ?? 4));
+  const physicalSizeMm = Number(options.physicalSizeMm ?? 35);
+  const totalModules = matrix.length + quietZone * 2;
+  const moduleSizeMm = physicalSizeMm / totalModules;
+  const dpi = Number(options.dpi ?? 300);
+  const modulePixels = moduleSizeMm / 25.4 * dpi;
+  const recommendedMinimumModuleMm = Number(options.minimumModuleMm ?? 0.40);
+  return {
+    mode: "print",
+    physicalSizeMm,
+    quietZone,
+    moduleSizeMm,
+    modulePixelsAtDpi: modulePixels,
+    dpi,
+    recommendedMinimumModuleMm,
+    meetsRecommendedModuleSize: moduleSizeMm >= recommendedMinimumModuleMm,
+    recommendedMinimumPhysicalSizeMm: totalModules * recommendedMinimumModuleMm,
+    palette: PRINT_PALETTE,
+    recommendations: [
+      "Use classic rendering for print unless a styled output has been physically validated.",
+      "Keep at least a 4-module quiet zone.",
+      `Target at least ${recommendedMinimumModuleMm.toFixed(2)} mm per module for general-purpose printing.`,
+      "Avoid glossy reflections and low-ink/toner modes when reliable color classification matters."
+    ]
+  };
+}
+
+function resolveLogoRenderOptions(options, matrixSize, moduleSize, quietZone, palette, codeOrMatrix = null) {
+  if (!options.logo) return null;
+
+  const nested = (
+    options.logo &&
+    typeof options.logo === "object" &&
+    Object.prototype.hasOwnProperty.call(options.logo, "source")
+  ) ? options.logo : null;
+  const source = nested ? nested.source : options.logo;
+  if (!source) return null;
+
+  const requestedSize = nested?.size ?? options.logoSize ?? 0.18;
+  const autoSize = String(requestedSize).toLowerCase() === "auto";
+  const rawSize = Number(requestedSize);
+  const sizeRatio = autoSize
+    ? estimateSafeLogoSize(codeOrMatrix, { ...options, clearBackground: nested?.clearBackground ?? options.logoClearBackground })
+    : Math.max(0.05, Math.min(0.30, Number.isFinite(rawSize) ? rawSize : 0.18));
+  const rawPadding = Number(nested?.padding ?? options.logoPadding ?? 0.65);
+  const rawRadius = Number(nested?.radius ?? options.logoRadius ?? 0.8);
+  const paddingModules = Math.max(0, Number.isFinite(rawPadding) ? rawPadding : 0.65);
+  const radiusModules = Math.max(0, Number.isFinite(rawRadius) ? rawRadius : 0.8);
+  const clearBackground = Boolean(nested?.clearBackground ?? options.logoClearBackground ?? false);
+  const backgroundColor = nested?.backgroundColor ?? options.logoBackgroundColor ?? palette.white;
+
+  const codePixels = matrixSize * moduleSize;
+  const canvasPixels = (matrixSize + quietZone * 2) * moduleSize;
+  const logoPixels = Math.max(1, codePixels * sizeRatio);
+  const center = canvasPixels / 2;
+  const paddingPixels = paddingModules * moduleSize;
+  const backgroundPixels = logoPixels + paddingPixels * 2;
+
+  return {
+    source,
+    sizeRatio,
+    clearBackground,
+    backgroundColor,
+    logoX: center - logoPixels / 2,
+    logoY: center - logoPixels / 2,
+    logoSize: logoPixels,
+    backgroundX: center - backgroundPixels / 2,
+    backgroundY: center - backgroundPixels / 2,
+    backgroundSize: backgroundPixels,
+    backgroundRadius: radiusModules * moduleSize
+  };
+}
+
+function canvasLogoSource(source) {
+  if (!source || typeof source === "string") return source;
+  if (source.data && Number.isInteger(source.width) && Number.isInteger(source.height)) {
+    let scratch = null;
+    if (typeof OffscreenCanvas !== "undefined") {
+      scratch = new OffscreenCanvas(source.width, source.height);
+    } else if (typeof document !== "undefined") {
+      scratch = document.createElement("canvas");
+      scratch.width = source.width;
+      scratch.height = source.height;
+    }
+    if (!scratch) return source;
+    const ctx = scratch.getContext("2d");
+    if (!ctx) return source;
+    const pixels = source.data instanceof Uint8ClampedArray
+      ? source.data
+      : new Uint8ClampedArray(source.data);
+    ctx.putImageData(new ImageData(pixels, source.width, source.height), 0, 0);
+    return scratch;
+  }
+  return source;
+}
+
+function logoSourceDimensions(source) {
+  const width = source?.naturalWidth ?? source?.videoWidth ?? source?.width;
+  const height = source?.naturalHeight ?? source?.videoHeight ?? source?.height;
+  if (!(Number(width) > 0 && Number(height) > 0)) return null;
+  return { width: Number(width), height: Number(height) };
+}
+
+function containRect(x, y, size, dimensions) {
+  if (!dimensions) return { x, y, width: size, height: size };
+  const scale = Math.min(size / dimensions.width, size / dimensions.height);
+  const width = dimensions.width * scale;
+  const height = dimensions.height * scale;
+  return {
+    x: x + (size - width) / 2,
+    y: y + (size - height) / 2,
+    width,
+    height
+  };
+}
+
+function drawLogoToCanvas(ctx, logo, palette) {
+  if (!logo) return;
+  if (logo.clearBackground) {
+    ctx.fillStyle = logo.backgroundColor || palette.white;
+    roundedRectPath(
+      ctx,
+      logo.backgroundX,
+      logo.backgroundY,
+      logo.backgroundSize,
+      logo.backgroundSize,
+      logo.backgroundRadius
+    );
+    ctx.fill();
+  }
+
+  const source = canvasLogoSource(logo.source);
+  assert(
+    source && typeof source !== "string",
+    "renderToCanvas() logo must be a loaded CanvasImageSource or ImageData-like object. Load URL/data-URL logos into an Image first."
+  );
+  const rect = containRect(logo.logoX, logo.logoY, logo.logoSize, logoSourceDimensions(source));
+  const previousSmoothing = ctx.imageSmoothingEnabled;
+  ctx.imageSmoothingEnabled = true;
+  ctx.drawImage(source, rect.x, rect.y, rect.width, rect.height);
+  ctx.imageSmoothingEnabled = previousSmoothing;
+}
+
+function blendImagePixel(data, width, x, y, rgb, alpha) {
+  if (x < 0 || y < 0 || x >= width) return;
+  const height = data.length / 4 / width;
+  if (y >= height) return;
+  const p = (y * width + x) * 4;
+  const a = Math.max(0, Math.min(1, alpha));
+  data[p] = Math.round(data[p] * (1 - a) + rgb.r * a);
+  data[p + 1] = Math.round(data[p + 1] * (1 - a) + rgb.g * a);
+  data[p + 2] = Math.round(data[p + 2] * (1 - a) + rgb.b * a);
+  data[p + 3] = 255;
+}
+
+function drawLogoToImageData(data, width, logo) {
+  if (!logo) return;
+  if (logo.clearBackground) {
+    const rgb = hexToRgb(logo.backgroundColor);
+    fillImageRoundedRect(
+      data,
+      width,
+      Math.round(logo.backgroundX),
+      Math.round(logo.backgroundY),
+      Math.round(logo.backgroundSize),
+      Math.round(logo.backgroundSize),
+      Math.round(logo.backgroundRadius),
+      rgb
+    );
+  }
+
+  const source = logo.source;
+  assert(
+    source?.data && Number.isInteger(source.width) && Number.isInteger(source.height),
+    "renderToImageData() logo must be an ImageData-like object with width, height, and RGBA data."
+  );
+  const dest = containRect(logo.logoX, logo.logoY, logo.logoSize, {
+    width: source.width,
+    height: source.height
+  });
+  const x0 = Math.round(dest.x);
+  const y0 = Math.round(dest.y);
+  const destWidth = Math.max(1, Math.round(dest.width));
+  const destHeight = Math.max(1, Math.round(dest.height));
+  const src = source.data;
+
+  for (let y = 0; y < destHeight; y++) {
+    const sy = Math.min(source.height - 1, Math.floor((y + 0.5) * source.height / destHeight));
+    for (let x = 0; x < destWidth; x++) {
+      const sx = Math.min(source.width - 1, Math.floor((x + 0.5) * source.width / destWidth));
+      const p = (sy * source.width + sx) * 4;
+      const alpha = (src[p + 3] ?? 255) / 255;
+      if (alpha <= 0) continue;
+      blendImagePixel(data, width, x0 + x, y0 + y, {
+        r: src[p],
+        g: src[p + 1],
+        b: src[p + 2]
+      }, alpha);
+    }
+  }
+}
+
+function escapeXmlAttribute(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;");
+}
+
+function svgRect(x, y, width, height, fill, radius = 0) {
+  const rounded = radius > 0 ? ` rx="${radius}" ry="${radius}"` : "";
+  return `<rect x="${x}" y="${y}" width="${width}" height="${height}" fill="${escapeXmlAttribute(fill)}"${rounded}/>`;
+}
+
+function svgLogoHref(source) {
+  if (typeof source === "string") return source;
+  if (typeof source?.src === "string" && source.src) return source.src;
+  return null;
+}
+
+function resolveRenderSizing(options, matrixSize) {
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const requestedQuietZone = Math.max(0, Math.floor(options.quietZone ?? 4));
+  const quietZone = mode === RENDER_MODES.PRINT && options.allowUnsafePrintQuietZone !== true
+    ? Math.max(4, requestedQuietZone)
+    : requestedQuietZone;
+  const totalModules = matrixSize + quietZone * 2;
+  const hasImageSize = options.imageSize !== undefined && options.imageSize !== null;
+  const hasModuleSize = options.moduleSize !== undefined && options.moduleSize !== null;
+
+  let pixelSize;
+  if (hasImageSize) {
+    const requested = Number(options.imageSize);
+    assert(Number.isFinite(requested) && requested > 0, "imageSize must be a positive number of pixels.");
+    pixelSize = Math.max(totalModules, Math.round(requested));
+  } else if (hasModuleSize) {
+    const requested = Number(options.moduleSize);
+    assert(Number.isFinite(requested) && requested > 0, "moduleSize must be a positive number of pixels.");
+    const moduleSize = Math.max(1, Math.floor(requested));
+    pixelSize = totalModules * moduleSize;
+  } else {
+    // A practical export default that is large enough for screens/social use
+    // while keeping the API independent from the encoded matrix version.
+    pixelSize = Math.max(totalModules, 720);
+  }
+
+  return {
+    quietZone,
+    totalModules,
+    pixelSize,
+    moduleSize: pixelSize / totalModules,
+    mode
+  };
+}
+
+function rasterModuleRect(row, col, quietZone, moduleSize) {
+  const x0 = Math.round((col + quietZone) * moduleSize);
+  const y0 = Math.round((row + quietZone) * moduleSize);
+  const x1 = Math.round((col + quietZone + 1) * moduleSize);
+  const y1 = Math.round((row + quietZone + 1) * moduleSize);
+  return {
+    x: x0,
+    y: y0,
+    width: Math.max(1, x1 - x0),
+    height: Math.max(1, y1 - y0)
+  };
+}
+
 function renderToCanvas(codeOrMatrix, canvas, options = {}) {
   assert(canvas && typeof canvas.getContext === "function", "A canvas element is required.");
   const matrix = Array.isArray(codeOrMatrix) ? codeOrMatrix : codeOrMatrix.matrix;
   assert(Array.isArray(matrix) && matrix.length > 0, "A matrix is required.");
-  const moduleSize = Math.max(1, Math.floor(options.moduleSize ?? 12));
-  const quietZone = Math.max(0, Math.floor(options.quietZone ?? 4));
-  const palette = resolvePalette(options.palette);
-  const paletteValues = paletteRgb(options.palette);
-  const style = normalizeRenderStyle(options.style);
+  const sizing = resolveRenderSizing(options, matrix.length);
+  const { moduleSize, quietZone, pixelSize } = sizing;
+  const palette = resolveRenderPalette(options);
+  const paletteValues = paletteRgb(palette);
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const style = normalizeRenderStyle(mode === RENDER_MODES.PRINT && options.allowStyledPrint !== true ? RENDER_STYLES.CLASSIC : options.style);
   const layout = renderLayoutForMatrix(matrix);
+  const cellEncoding = inferCellEncoding(codeOrMatrix, matrix, layout);
   const size = matrix.length;
-  const pixelSize = (size + quietZone * 2) * moduleSize;
+  const logo = resolveLogoRenderOptions(options, size, moduleSize, quietZone, palette, codeOrMatrix);
 
   canvas.width = pixelSize;
   canvas.height = pixelSize;
@@ -3608,12 +5227,21 @@ function renderToCanvas(codeOrMatrix, canvas, options = {}) {
     for (let c = 0; c < size; c++) {
       const cell = matrix[r][c];
       const structural = isStructuralRenderCell(layout, r, c, cell);
-      const x = (c + quietZone) * moduleSize;
-      const y = (r + quietZone) * moduleSize;
+      const rect = rasterModuleRect(r, c, quietZone, moduleSize);
+      const { x, y, width: cellWidth, height: cellHeight } = rect;
+      const cellSize = Math.min(cellWidth, cellHeight);
+
+      if (cellEncoding === CELL_ENCODINGS.TRIANGLE16 && !structural) {
+        // Experimental Triangle16 always renders payload cells with exact,
+        // hard-edged geometry. Decorative per-cell styles would contaminate the
+        // two independent color samples and reduce scan reliability.
+        drawTriangleCellCanvas(ctx, x, y, cellWidth, cellHeight, cell, palette);
+        continue;
+      }
 
       if (style === RENDER_STYLES.CLASSIC || structural) {
         ctx.fillStyle = cellColor(cell, palette);
-        ctx.fillRect(x, y, moduleSize, moduleSize);
+        ctx.fillRect(x, y, cellWidth, cellHeight);
         continue;
       }
 
@@ -3623,28 +5251,29 @@ function renderToCanvas(codeOrMatrix, canvas, options = {}) {
         const opacity = depthOpacity(r, c, cell);
         const base = mixRgb(paletteValues.white, rgb, opacity);
         ctx.fillStyle = rgbCss(base);
-        ctx.fillRect(x, y, moduleSize, moduleSize);
+        ctx.fillRect(x, y, cellWidth, cellHeight);
 
-        if (moduleSize >= 6) {
-          const edge = Math.max(1, Math.floor(moduleSize * 0.08));
+        if (cellSize >= 6) {
+          const edge = Math.max(1, Math.floor(cellSize * 0.08));
           const highlight = mixRgb(base, paletteValues.white, 0.17);
           const shadow = mixRgb(base, paletteValues.black, 0.12);
           ctx.fillStyle = rgbCss(highlight);
-          ctx.fillRect(x, y, moduleSize, edge);
-          ctx.fillRect(x, y, edge, moduleSize);
+          ctx.fillRect(x, y, cellWidth, edge);
+          ctx.fillRect(x, y, edge, cellHeight);
           ctx.fillStyle = rgbCss(shadow);
-          ctx.fillRect(x, y + moduleSize - edge, moduleSize, edge);
-          ctx.fillRect(x + moduleSize - edge, y, edge, moduleSize);
+          ctx.fillRect(x, y + cellHeight - edge, cellWidth, edge);
+          ctx.fillRect(x + cellWidth - edge, y, edge, cellHeight);
         }
         continue;
       }
 
       if (style === RENDER_STYLES.SOFT) {
-        const inset = moduleSize >= 6 ? Math.max(1, Math.floor(moduleSize * 0.07)) : 0;
-        const width = moduleSize - inset * 2;
-        const radius = Math.max(1, Math.floor(moduleSize * 0.20));
+        const inset = cellSize >= 6 ? Math.max(1, Math.floor(cellSize * 0.07)) : 0;
+        const width = cellWidth - inset * 2;
+        const height = cellHeight - inset * 2;
+        const radius = Math.max(1, Math.floor(cellSize * 0.20));
         ctx.fillStyle = cellColor(cell, palette);
-        roundedRectPath(ctx, x + inset, y + inset, width, width, radius);
+        roundedRectPath(ctx, x + inset, y + inset, width, height, radius);
         ctx.fill();
         continue;
       }
@@ -3653,37 +5282,41 @@ function renderToCanvas(codeOrMatrix, canvas, options = {}) {
         // Keep the exact encoded color across the full module, then limit the
         // recessed effect to a narrow edge band so center sampling stays intact.
         ctx.fillStyle = cellColor(cell, palette);
-        ctx.fillRect(x, y, moduleSize, moduleSize);
+        ctx.fillRect(x, y, cellWidth, cellHeight);
         if (cell === CELL.WHITE) continue;
 
-        const edge = safeStyleEdge(moduleSize);
+        const edge = safeStyleEdge(cellSize);
         if (edge > 0) {
           const fx = insetStyleColors(rgb, paletteValues);
           ctx.fillStyle = rgbCss(fx.shadow);
-          ctx.fillRect(x, y, moduleSize, edge);
-          ctx.fillRect(x, y, edge, moduleSize);
+          ctx.fillRect(x, y, cellWidth, edge);
+          ctx.fillRect(x, y, edge, cellHeight);
           ctx.fillStyle = rgbCss(fx.highlight);
-          ctx.fillRect(x, y + moduleSize - edge, moduleSize, edge);
-          ctx.fillRect(x + moduleSize - edge, y, edge, moduleSize);
+          ctx.fillRect(x, y + cellHeight - edge, cellWidth, edge);
+          ctx.fillRect(x + cellWidth - edge, y, edge, cellHeight);
         }
       }
     }
   }
+  drawLogoToCanvas(ctx, logo, palette);
   return canvas;
 }
 
 function renderToImageData(codeOrMatrix, options = {}) {
   const matrix = Array.isArray(codeOrMatrix) ? codeOrMatrix : codeOrMatrix.matrix;
   assert(Array.isArray(matrix) && matrix.length > 0, "A matrix is required.");
-  const moduleSize = Math.max(1, Math.floor(options.moduleSize ?? 8));
-  const quietZone = Math.max(0, Math.floor(options.quietZone ?? 4));
-  const palette = paletteRgb(options.palette);
-  const style = normalizeRenderStyle(options.style);
+  const sizing = resolveRenderSizing(options, matrix.length);
+  const { moduleSize, quietZone, pixelSize } = sizing;
+  const resolvedPalette = resolveRenderPalette(options);
+  const palette = paletteRgb(resolvedPalette);
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const style = normalizeRenderStyle(mode === RENDER_MODES.PRINT && options.allowStyledPrint !== true ? RENDER_STYLES.CLASSIC : options.style);
   const layout = renderLayoutForMatrix(matrix);
+  const cellEncoding = inferCellEncoding(codeOrMatrix, matrix, layout);
   const size = matrix.length;
-  const pixelSize = (size + quietZone * 2) * moduleSize;
   const data = new Uint8ClampedArray(pixelSize * pixelSize * 4);
   const white = palette.white;
+  const logo = resolveLogoRenderOptions(options, size, moduleSize, quietZone, resolvedPalette, codeOrMatrix);
 
   for (let i = 0; i < pixelSize * pixelSize; i++) {
     const p = i * 4;
@@ -3696,28 +5329,119 @@ function renderToImageData(codeOrMatrix, options = {}) {
   for (let r = 0; r < size; r++) {
     for (let c = 0; c < size; c++) {
       const cell = matrix[r][c];
-      const rgb = cellRgb(cell, palette);
       const structural = isStructuralRenderCell(layout, r, c, cell);
-      const y0 = (r + quietZone) * moduleSize;
-      const x0 = (c + quietZone) * moduleSize;
+      const rect = rasterModuleRect(r, c, quietZone, moduleSize);
+      const x0 = rect.x;
+      const y0 = rect.y;
+      const cellWidth = rect.width;
+      const cellHeight = rect.height;
+      const cellSize = Math.min(cellWidth, cellHeight);
+
+      if (cellEncoding === CELL_ENCODINGS.TRIANGLE16 && !structural) {
+        fillImageTriangleCell(data, pixelSize, x0, y0, cellWidth, cellHeight, cell, palette);
+        continue;
+      }
+
+      const rgb = cellRgb(cell, palette);
 
       if (style === RENDER_STYLES.CLASSIC || structural) {
-        fillImageRect(data, pixelSize, x0, y0, moduleSize, moduleSize, rgb);
+        fillImageRect(data, pixelSize, x0, y0, cellWidth, cellHeight, rgb);
         continue;
       }
 
       if (style === RENDER_STYLES.DEPTH) {
         const opacity = depthOpacity(r, c, cell);
         const base = mixRgb(white, rgb, opacity);
-        fillImageRect(data, pixelSize, x0, y0, moduleSize, moduleSize, base);
-        if (moduleSize >= 6) {
-          const edge = Math.max(1, Math.floor(moduleSize * 0.08));
+        fillImageRect(data, pixelSize, x0, y0, cellWidth, cellHeight, base);
+        if (cellSize >= 6) {
+          const edge = Math.max(1, Math.floor(cellSize * 0.08));
           const highlight = mixRgb(base, white, 0.17);
           const shadow = mixRgb(base, palette.black, 0.12);
-          fillImageRect(data, pixelSize, x0, y0, moduleSize, edge, highlight);
-          fillImageRect(data, pixelSize, x0, y0, edge, moduleSize, highlight);
-          fillImageRect(data, pixelSize, x0, y0 + moduleSize - edge, moduleSize, edge, shadow);
-          fillImageRect(data, pixelSize, x0 + moduleSize - edge, y0, edge, moduleSize, shadow);
+          fillImageRect(data, pixelSize, x0, y0, cellWidth, edge, highlight);
+          fillImageRect(data, pixelSize, x0, y0, edge, cellHeight, highlight);
+          fillImageRect(data, pixelSize, x0, y0 + cellHeight - edge, cellWidth, edge, shadow);
+          fillImageRect(data, pixelSize, x0 + cellWidth - edge, y0, edge, cellHeight, shadow);
+        }
+        continue;
+      }
+
+      if (style === RENDER_STYLES.SOFT) {
+        const inset = cellSize >= 6 ? Math.max(1, Math.floor(cellSize * 0.07)) : 0;
+        const width = cellWidth - inset * 2;
+        const height = cellHeight - inset * 2;
+        const radius = Math.max(1, Math.floor(cellSize * 0.20));
+        fillImageRoundedRect(data, pixelSize, x0 + inset, y0 + inset, width, height, radius, rgb);
+        continue;
+      }
+
+      if (style === RENDER_STYLES.INSET) {
+        fillImageRect(data, pixelSize, x0, y0, cellWidth, cellHeight, rgb);
+        if (cell === CELL.WHITE) continue;
+        const edge = safeStyleEdge(cellSize);
+        if (edge > 0) {
+          const fx = insetStyleColors(rgb, palette);
+          fillImageRect(data, pixelSize, x0, y0, cellWidth, edge, fx.shadow);
+          fillImageRect(data, pixelSize, x0, y0, edge, cellHeight, fx.shadow);
+          fillImageRect(data, pixelSize, x0, y0 + cellHeight - edge, cellWidth, edge, fx.highlight);
+          fillImageRect(data, pixelSize, x0 + cellWidth - edge, y0, edge, cellHeight, fx.highlight);
+        }
+      }
+    }
+  }
+
+  drawLogoToImageData(data, pixelSize, logo);
+
+  return { width: pixelSize, height: pixelSize, data };
+}
+
+/** Render a QuadQR code/matrix to a standalone SVG string. */
+function renderToSVG(codeOrMatrix, options = {}) {
+  const matrix = Array.isArray(codeOrMatrix) ? codeOrMatrix : codeOrMatrix.matrix;
+  assert(Array.isArray(matrix) && matrix.length > 0, "A matrix is required.");
+  const sizing = resolveRenderSizing(options, matrix.length);
+  const { moduleSize, quietZone, pixelSize } = sizing;
+  const palette = resolveRenderPalette(options);
+  const paletteValues = paletteRgb(palette);
+  const mode = normalizeRenderMode(options.mode ?? options.renderMode ?? RENDER_MODES.SCREEN);
+  const style = normalizeRenderStyle(mode === RENDER_MODES.PRINT && options.allowStyledPrint !== true ? RENDER_STYLES.CLASSIC : options.style);
+  const layout = renderLayoutForMatrix(matrix);
+  const cellEncoding = inferCellEncoding(codeOrMatrix, matrix, layout);
+  const size = matrix.length;
+  const logo = resolveLogoRenderOptions(options, size, moduleSize, quietZone, palette, codeOrMatrix);
+  const body = [svgRect(0, 0, pixelSize, pixelSize, palette.white)];
+
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      const cell = matrix[r][c];
+      const structural = isStructuralRenderCell(layout, r, c, cell);
+      const x = (c + quietZone) * moduleSize;
+      const y = (r + quietZone) * moduleSize;
+      const fill = cellEncoding === CELL_ENCODINGS.TRIANGLE16 && !structural ? null : cellColor(cell, palette);
+
+      if (cellEncoding === CELL_ENCODINGS.TRIANGLE16 && !structural) {
+        body.push(svgTriangleCell(x, y, moduleSize, cell, palette));
+        continue;
+      }
+
+      if (style === RENDER_STYLES.CLASSIC || structural) {
+        body.push(svgRect(x, y, moduleSize, moduleSize, fill));
+        continue;
+      }
+
+      const rgb = cellRgb(cell, paletteValues);
+
+      if (style === RENDER_STYLES.DEPTH) {
+        const opacity = depthOpacity(r, c, cell);
+        const base = mixRgb(paletteValues.white, rgb, opacity);
+        body.push(svgRect(x, y, moduleSize, moduleSize, rgbCss(base)));
+        if (moduleSize >= 6) {
+          const edge = Math.max(1, Math.floor(moduleSize * 0.08));
+          const highlight = rgbCss(mixRgb(base, paletteValues.white, 0.17));
+          const shadow = rgbCss(mixRgb(base, paletteValues.black, 0.12));
+          body.push(svgRect(x, y, moduleSize, edge, highlight));
+          body.push(svgRect(x, y, edge, moduleSize, highlight));
+          body.push(svgRect(x, y + moduleSize - edge, moduleSize, edge, shadow));
+          body.push(svgRect(x + moduleSize - edge, y, edge, moduleSize, shadow));
         }
         continue;
       }
@@ -3726,26 +5450,51 @@ function renderToImageData(codeOrMatrix, options = {}) {
         const inset = moduleSize >= 6 ? Math.max(1, Math.floor(moduleSize * 0.07)) : 0;
         const width = moduleSize - inset * 2;
         const radius = Math.max(1, Math.floor(moduleSize * 0.20));
-        fillImageRoundedRect(data, pixelSize, x0 + inset, y0 + inset, width, width, radius, rgb);
+        body.push(svgRect(x + inset, y + inset, width, width, fill, radius));
         continue;
       }
 
       if (style === RENDER_STYLES.INSET) {
-        fillImageRect(data, pixelSize, x0, y0, moduleSize, moduleSize, rgb);
+        body.push(svgRect(x, y, moduleSize, moduleSize, fill));
         if (cell === CELL.WHITE) continue;
         const edge = safeStyleEdge(moduleSize);
         if (edge > 0) {
-          const fx = insetStyleColors(rgb, palette);
-          fillImageRect(data, pixelSize, x0, y0, moduleSize, edge, fx.shadow);
-          fillImageRect(data, pixelSize, x0, y0, edge, moduleSize, fx.shadow);
-          fillImageRect(data, pixelSize, x0, y0 + moduleSize - edge, moduleSize, edge, fx.highlight);
-          fillImageRect(data, pixelSize, x0 + moduleSize - edge, y0, edge, moduleSize, fx.highlight);
+          const fx = insetStyleColors(rgb, paletteValues);
+          const shadow = rgbCss(fx.shadow);
+          const highlight = rgbCss(fx.highlight);
+          body.push(svgRect(x, y, moduleSize, edge, shadow));
+          body.push(svgRect(x, y, edge, moduleSize, shadow));
+          body.push(svgRect(x, y + moduleSize - edge, moduleSize, edge, highlight));
+          body.push(svgRect(x + moduleSize - edge, y, edge, moduleSize, highlight));
         }
       }
     }
   }
 
-  return { width: pixelSize, height: pixelSize, data };
+  if (logo) {
+    if (logo.clearBackground) {
+      body.push(svgRect(
+        logo.backgroundX,
+        logo.backgroundY,
+        logo.backgroundSize,
+        logo.backgroundSize,
+        logo.backgroundColor,
+        logo.backgroundRadius
+      ));
+    }
+    const href = svgLogoHref(logo.source);
+    assert(href, "renderToSVG() logo must be a URL/data URL string or an object with a src string.");
+    body.push(
+      `<image href="${escapeXmlAttribute(href)}" x="${logo.logoX}" y="${logo.logoY}" width="${logo.logoSize}" height="${logo.logoSize}" preserveAspectRatio="xMidYMid meet"/>`
+    );
+  }
+
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${pixelSize}" height="${pixelSize}" viewBox="0 0 ${pixelSize} ${pixelSize}" shape-rendering="crispEdges">`,
+    ...body,
+    "</svg>"
+  ].join("\n");
 }
 
 function clampNumber(value, min, max) {
@@ -3898,6 +5647,60 @@ function classifySampledRgbGrid(rgbGrid, classifier, layout = null) {
   };
 }
 
+function classifyTriangleSampledRgbGrid(rgbGrid, triangleGrid, classifier, layout) {
+  const size = rgbGrid.length;
+  const matrix = make2D(size, CELL.WHITE);
+  const confidence = make2D(size, 1);
+  const dataClassifier = {
+    ...classifier,
+    entries: classifier.entries.filter(({ cell }) => cell !== CELL.BLACK)
+  };
+  let distanceSum = 0;
+  let confidenceSum = 0;
+  let minimumConfidence = 1;
+  let lowConfidenceCells = 0;
+
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      const isDataCell = layout && !layout.reserved[r][c];
+      if (!isDataCell) {
+        const classified = classifyRgb(rgbGrid[r][c], classifier);
+        matrix[r][c] = classified.cell;
+        confidence[r][c] = classified.confidence;
+        distanceSum += classified.distance;
+        confidenceSum += classified.confidence;
+        minimumConfidence = Math.min(minimumConfidence, classified.confidence);
+        if (classified.confidence < 0.4) lowConfidenceCells++;
+        continue;
+      }
+
+      const samples = triangleGrid?.[r]?.[c];
+      if (!samples) throw new Error("Triangle16 sampling grid is incomplete.");
+      const classifyData = (rgb) => classifier.dataMode === "hue"
+        ? classifyDataHue(rgb, classifier)
+        : classifyRgb(rgb, dataClassifier);
+      const first = classifyData(samples.first);
+      const second = classifyData(samples.second);
+      const cellConfidence = Math.min(first.confidence, second.confidence);
+      matrix[r][c] = packTriangleCell(first.cell, second.cell);
+      confidence[r][c] = cellConfidence;
+      distanceSum += (first.distance + second.distance) / 2;
+      confidenceSum += cellConfidence;
+      minimumConfidence = Math.min(minimumConfidence, cellConfidence);
+      if (cellConfidence < 0.4) lowConfidenceCells++;
+    }
+  }
+
+  return {
+    matrix,
+    confidence,
+    averageColorDistance: distanceSum / (size * size),
+    averageCellConfidence: confidenceSum / (size * size),
+    minimumCellConfidence: minimumConfidence,
+    lowConfidenceCells
+  };
+}
+
 function structuralAccuracy(matrix, layout) {
   let matches = 0;
   let total = 0;
@@ -3937,6 +5740,7 @@ function tryPerspectiveScan(imageData, options) {
     finderAutoColorAnalysisInset: options.finderAutoColorAnalysisInset,
     finderAutoColorMinimumInputRange: options.finderAutoColorMinimumInputRange,
     finderAutoColorTargetSamples: options.finderAutoColorTargetSamples,
+    preciseAlignment: options.preciseAlignment,
     diagnostics: options._visionDiagnostics,
     diagnosticLabel: options._diagnosticLabel ?? "normal"
   });
@@ -3962,9 +5766,18 @@ function tryPerspectiveScan(imageData, options) {
     let bestStructureScore = 0;
     for (const profile of sampleProfiles) {
       let sampled;
+      let triangleSampled = null;
       let observedPalette;
       try {
         sampled = samplePerspectiveMatrix(imageData, geometry.homography, layout.size, profile);
+        if (options.highDensitySampling !== false && options.triangle16 !== false) {
+          triangleSampled = samplePerspectiveTriangleMatrix(
+            imageData,
+            geometry.homography,
+            layout.size,
+            profile
+          );
+        }
         observedPalette = sampleObservedPalette(sampled.rgbGrid, layout.calibration, {
           robust: profile.robustCalibration
         });
@@ -4023,11 +5836,67 @@ function tryPerspectiveScan(imageData, options) {
         }
       };
 
+      const tryTriangleAttempt = (attempt, metadata = {}) => {
+        if (!triangleSampled?.triangleGrid) return false;
+        const activeObservedPalette = metadata.observedPalette ?? observedPalette;
+        const activeSamplingMode = metadata.samplingMode ?? `${profile.sampleMode}-triangle16`;
+        const classified = classifyTriangleSampledRgbGrid(
+          sampled.rgbGrid,
+          triangleSampled.triangleGrid,
+          attempt.classifier,
+          layout
+        );
+        const structureScore = structuralAccuracy(classified.matrix, layout);
+        bestStructureScore = Math.max(bestStructureScore, structureScore);
+        pushObservation(options, {
+          version: geometry.version,
+          matrix: classified.matrix,
+          confidence: classified.confidence,
+          geometry,
+          observedPalette: activeObservedPalette,
+          samplingMode: activeSamplingMode,
+          colorNormalization: attempt.colorNormalization,
+          cellEncoding: CELL_ENCODINGS.TRIANGLE16,
+          structureScore,
+          averageCellConfidence: classified.averageCellConfidence,
+          lowConfidenceCells: classified.lowConfidenceCells
+        });
+
+        try {
+          const decoded = decodeMatrix(classified.matrix, {
+            structureTolerance: options.structureTolerance ?? 0.18,
+            cellConfidence: classified.confidence,
+            cellEncodingHint: CELL_ENCODINGS.TRIANGLE16,
+            maxErasureConfidence: options.maxErasureConfidence
+          });
+          if (decoded.version !== geometry.version) return false;
+          results.push({
+            ...decoded,
+            perspectiveCorrected: true,
+            colorCalibrated: true,
+            colorNormalization: attempt.colorNormalization,
+            samplingMode: activeSamplingMode,
+            geometry,
+            observedPalette: activeObservedPalette,
+            averageColorDistance: classified.averageColorDistance,
+            averageCellConfidence: classified.averageCellConfidence,
+            minimumCellConfidence: classified.minimumCellConfidence,
+            lowConfidenceCells: classified.lowConfidenceCells,
+            rectified: options.includeRectified
+              ? rectifyImageData(imageData, geometry.homography, layout.size, options.rectifiedModuleSize ?? 8)
+              : undefined
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+
       // Fast path: preserve the original observed-RGB classifier first, then
       // try per-channel white balancing. Most clean frames stop here without
       // paying for the more expensive spatial normalization fallback.
       for (const attempt of paletteClassifierAttempts(observedPalette)) {
-        if (tryAttempt(attempt, sampled.rgbGrid)) {
+        if (tryAttempt(attempt, sampled.rgbGrid) || tryTriangleAttempt(attempt)) {
           geometryDecoded = true;
           break;
         }
@@ -4154,17 +6023,30 @@ function tryPerspectiveScan(imageData, options) {
         [step, -step], [step, step], [-step, -step], [-step, step]
       ];
       const refinementCandidates = [];
+      const triangleRefinementCandidates = [];
 
       for (const [offsetX, offsetY] of refinementOffsets) {
         let sampled;
+        let triangleSampled = null;
         let observedPalette;
         try {
-          sampled = samplePerspectiveMatrix(imageData, geometry.homography, layout.size, {
+          const samplingOptions = {
             sampleMode: "cross",
             sampleRadius: 0,
             sampleOffsetX: offsetX,
-            sampleOffsetY: offsetY
-          });
+            sampleOffsetY: offsetY,
+            triangleSampleInset: options.highDensitySampleInset ?? options.triangleSampleInset,
+            triangleSampleRadius: options.highDensitySampleRadius ?? options.triangleSampleRadius
+          };
+          sampled = samplePerspectiveMatrix(imageData, geometry.homography, layout.size, samplingOptions);
+          if (options.highDensitySampling !== false && options.triangle16 !== false) {
+            triangleSampled = samplePerspectiveTriangleMatrix(
+              imageData,
+              geometry.homography,
+              layout.size,
+              samplingOptions
+            );
+          }
           observedPalette = sampleObservedPalette(sampled.rgbGrid, layout.calibration, { robust: true });
         } catch {
           continue;
@@ -4194,30 +6076,80 @@ function tryPerspectiveScan(imageData, options) {
 
           // Do not spend RS work on a refinement that made the known finder /
           // alignment structure worse. This keeps the recovery path bounded.
-          if (structureScore < (options.refinementDecodeThreshold ?? 0.95)) continue;
-          refinementCandidates.push({
-            attempt,
-            classified,
-            observedPalette,
-            offsetX,
-            offsetY,
-            structureScore
-          });
+          if (structureScore >= (options.refinementDecodeThreshold ?? 0.95)) {
+            refinementCandidates.push({
+              attempt,
+              classified,
+              observedPalette,
+              offsetX,
+              offsetY,
+              structureScore,
+              cellEncoding: CELL_ENCODINGS.RGBW,
+              samplingMode: "refined-center"
+            });
+          }
+
+          if (triangleSampled?.triangleGrid) {
+            const triangleClassified = classifyTriangleSampledRgbGrid(
+              sampled.rgbGrid,
+              triangleSampled.triangleGrid,
+              attempt.classifier,
+              layout
+            );
+            const triangleStructureScore = structuralAccuracy(triangleClassified.matrix, layout);
+            bestStructureScore = Math.max(bestStructureScore, triangleStructureScore);
+            pushObservation(options, {
+              version: geometry.version,
+              matrix: triangleClassified.matrix,
+              confidence: triangleClassified.confidence,
+              geometry,
+              observedPalette,
+              samplingMode: "refined-triangle16",
+              samplingOffset: { x: offsetX, y: offsetY },
+              colorNormalization: attempt.colorNormalization,
+              cellEncoding: CELL_ENCODINGS.TRIANGLE16,
+              structureScore: triangleStructureScore,
+              averageCellConfidence: triangleClassified.averageCellConfidence,
+              lowConfidenceCells: triangleClassified.lowConfidenceCells
+            });
+            if (triangleStructureScore >= (options.refinementDecodeThreshold ?? 0.95)) {
+              triangleRefinementCandidates.push({
+                attempt,
+                classified: triangleClassified,
+                observedPalette,
+                offsetX,
+                offsetY,
+                structureScore: triangleStructureScore,
+                cellEncoding: CELL_ENCODINGS.TRIANGLE16,
+                samplingMode: "refined-triangle16"
+              });
+            }
+          }
         }
       }
 
-      refinementCandidates.sort((a, b) =>
+      const sortRefinementCandidates = (items) => items.sort((a, b) =>
         (b.structureScore - a.structureScore) ||
         (b.classified.averageCellConfidence - a.classified.averageCellConfidence) ||
         (a.classified.averageColorDistance - b.classified.averageColorDistance)
       );
+      sortRefinementCandidates(refinementCandidates);
+      sortRefinementCandidates(triangleRefinementCandidates);
 
       const decodeLimit = Math.max(1, Math.min(8, Math.round(options.refinementDecodeCandidates ?? 4)));
-      for (const candidate of refinementCandidates.slice(0, decodeLimit)) {
+      // Keep separate per-encoding limits. A Triangle16 image can produce very
+      // confident but meaningless centre samples, and those must not crowd out
+      // the dual-region candidates during the final bounded recovery pass.
+      const decodeCandidates = [
+        ...refinementCandidates.slice(0, decodeLimit),
+        ...triangleRefinementCandidates.slice(0, decodeLimit)
+      ];
+      for (const candidate of decodeCandidates) {
         try {
           const decoded = decodeMatrix(candidate.classified.matrix, {
             structureTolerance: options.structureTolerance ?? 0.18,
             cellConfidence: candidate.classified.confidence,
+            cellEncodingHint: candidate.cellEncoding,
             maxErasureConfidence: options.maxErasureConfidence
           });
           if (decoded.version !== geometry.version) continue;
@@ -4228,7 +6160,7 @@ function tryPerspectiveScan(imageData, options) {
             samplingOffset: { x: candidate.offsetX, y: candidate.offsetY },
             colorCalibrated: true,
             colorNormalization: candidate.attempt.colorNormalization,
-            samplingMode: "refined-center",
+            samplingMode: candidate.samplingMode,
             geometry,
             observedPalette: candidate.observedPalette,
             averageColorDistance: candidate.classified.averageColorDistance,
@@ -4278,6 +6210,15 @@ function tryAxisAlignedScan(imageData, options) {
     for (let profileIndex = 0; profileIndex < radiusProfiles.length && !accepted; profileIndex++) {
       try {
         const sampled = sampleAxisAlignedGrid(imageData, bounds, size, radiusProfiles[profileIndex]);
+        const triangleSampled = options.highDensitySampling === false || options.triangle16 === false
+          ? null
+          : sampleAxisAlignedTriangleGrid(
+              imageData,
+              bounds,
+              size,
+              Math.min(0.10, Math.max(0.04, radiusProfiles[profileIndex] * 0.48)),
+              options.highDensitySampleInset ?? options.triangleSampleInset ?? 0.28
+            );
         const layout = createLayout(version);
         const classifierAttempts = [];
         try {
@@ -4317,45 +6258,70 @@ function tryAxisAlignedScan(imageData, options) {
         });
 
         for (const attempt of classifierAttempts) {
-          try {
-            const classified = classifySampledRgbGrid(attempt.rgbGrid ?? sampled.rgbGrid, attempt.classifier, layout);
-            const structureScore = structuralAccuracy(classified.matrix, layout);
-            pushObservation(options, {
-              version,
-              matrix: classified.matrix,
-              confidence: classified.confidence,
-              bounds,
-              samplingMode: profileIndex === 0 ? "axis" : "axis-center",
-              colorNormalization: attempt.colorNormalization,
-              structureScore,
-              averageCellConfidence: classified.averageCellConfidence,
-              lowConfidenceCells: classified.lowConfidenceCells
-            });
-            const decoded = decodeMatrix(classified.matrix, {
-              structureTolerance: options.structureTolerance ?? 0.12,
-              cellConfidence: classified.confidence,
-              maxErasureConfidence: options.maxErasureConfidence
+          const centerGrid = attempt.rgbGrid ?? sampled.rgbGrid;
+          const samplingMode = profileIndex === 0 ? "axis" : "axis-center";
+          const classifiedAttempts = [{
+            classified: classifySampledRgbGrid(centerGrid, attempt.classifier, layout),
+            cellEncoding: CELL_ENCODINGS.RGBW,
+            samplingMode
+          }];
+          if (triangleSampled?.triangleGrid && attempt.rgbGrid === sampled.rgbGrid) {
+            classifiedAttempts.push({
+              classified: classifyTriangleSampledRgbGrid(
+                centerGrid,
+                triangleSampled.triangleGrid,
+                attempt.classifier,
+                layout
+              ),
+              cellEncoding: CELL_ENCODINGS.TRIANGLE16,
+              samplingMode: `${samplingMode}-triangle16`
             });
-            candidates.push({
-              ...decoded,
-              bounds,
-              sampledVersion: version,
-              moduleWidth: moduleW,
-              moduleHeight: moduleH,
-              perspectiveCorrected: false,
-              colorCalibrated: attempt.calibrated,
-              colorNormalization: attempt.colorNormalization,
-              samplingMode: profileIndex === 0 ? "axis" : "axis-center",
-              averageColorDistance: classified.averageColorDistance,
-              averageCellConfidence: classified.averageCellConfidence,
-              minimumCellConfidence: classified.minimumCellConfidence,
-              lowConfidenceCells: classified.lowConfidenceCells
-            });
-            accepted = true;
-            break;
-          } catch {
-            // Try next classifier/profile.
           }
+
+          for (const classifiedAttempt of classifiedAttempts) {
+            try {
+              const classified = classifiedAttempt.classified;
+              const structureScore = structuralAccuracy(classified.matrix, layout);
+              pushObservation(options, {
+                version,
+                matrix: classified.matrix,
+                confidence: classified.confidence,
+                bounds,
+                samplingMode: classifiedAttempt.samplingMode,
+                colorNormalization: attempt.colorNormalization,
+                cellEncoding: classifiedAttempt.cellEncoding,
+                structureScore,
+                averageCellConfidence: classified.averageCellConfidence,
+                lowConfidenceCells: classified.lowConfidenceCells
+              });
+              const decoded = decodeMatrix(classified.matrix, {
+                structureTolerance: options.structureTolerance ?? 0.12,
+                cellConfidence: classified.confidence,
+                cellEncodingHint: classifiedAttempt.cellEncoding,
+                maxErasureConfidence: options.maxErasureConfidence
+              });
+              candidates.push({
+                ...decoded,
+                bounds,
+                sampledVersion: version,
+                moduleWidth: moduleW,
+                moduleHeight: moduleH,
+                perspectiveCorrected: false,
+                colorCalibrated: attempt.calibrated,
+                colorNormalization: attempt.colorNormalization,
+                samplingMode: classifiedAttempt.samplingMode,
+                averageColorDistance: classified.averageColorDistance,
+                averageCellConfidence: classified.averageCellConfidence,
+                minimumCellConfidence: classified.minimumCellConfidence,
+                lowConfidenceCells: classified.lowConfidenceCells
+              });
+              accepted = true;
+              break;
+            } catch {
+              // Try the next cell encoding/classifier/profile.
+            }
+          }
+          if (accepted) break;
         }
       } catch {
         // Try a narrower centre sample, then next version.
@@ -4369,6 +6335,364 @@ function tryAxisAlignedScan(imageData, options) {
   return candidates[0] ?? null;
 }
 
+const STRESS_PROFILES = Object.freeze([
+  Object.freeze({ id: "clean", label: "Clean", type: "clean", severity: 0, weight: 2 }),
+  Object.freeze({ id: "blur", label: "Blur", type: "blur", severity: 0.42, weight: 1 }),
+  Object.freeze({ id: "dark", label: "Low brightness", type: "brightness-low", severity: 0.48, weight: 1 }),
+  Object.freeze({ id: "bright", label: "High exposure", type: "brightness-high", severity: 0.34, weight: 1 }),
+  Object.freeze({ id: "shadow", label: "Uneven shadow", type: "shadow", severity: 0.55, weight: 1.2 }),
+  Object.freeze({ id: "contrast", label: "Contrast loss", type: "contrast-loss", severity: 0.42, weight: 1 }),
+  Object.freeze({ id: "perspective", label: "Perspective", type: "perspective", severity: 0.42, weight: 1.3 }),
+  Object.freeze({ id: "jpeg", label: "JPEG-like compression", type: "jpeg", severity: 0.50, weight: 0.8 }),
+  Object.freeze({ id: "downscale", label: "Downscale", type: "downscale", severity: 0.52, weight: 0.9 })
+]);
+
+function cloneImageDataLike(imageData) {
+  return { width: imageData.width, height: imageData.height, data: new Uint8ClampedArray(imageData.data) };
+}
+
+function sampleRgbaBilinear(imageData, x, y) {
+  const { width, height, data } = imageData;
+  const cx = clampNumber(x, 0, width - 1);
+  const cy = clampNumber(y, 0, height - 1);
+  const x0 = Math.floor(cx), y0 = Math.floor(cy);
+  const x1 = Math.min(width - 1, x0 + 1), y1 = Math.min(height - 1, y0 + 1);
+  const tx = cx - x0, ty = cy - y0;
+  const get = (xx, yy, channel) => data[(yy * width + xx) * 4 + channel];
+  const out = [0, 0, 0, 255];
+  for (let ch = 0; ch < 4; ch++) {
+    const a = get(x0, y0, ch) * (1 - tx) + get(x1, y0, ch) * tx;
+    const b = get(x0, y1, ch) * (1 - tx) + get(x1, y1, ch) * tx;
+    out[ch] = a * (1 - ty) + b * ty;
+  }
+  return out;
+}
+
+function resizeImageDataLike(imageData, width, height) {
+  width = Math.max(1, Math.round(width));
+  height = Math.max(1, Math.round(height));
+  const out = new Uint8ClampedArray(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const sx = (x + 0.5) * imageData.width / width - 0.5;
+      const sy = (y + 0.5) * imageData.height / height - 0.5;
+      const rgba = sampleRgbaBilinear(imageData, sx, sy);
+      const p = (y * width + x) * 4;
+      out[p] = rgba[0]; out[p + 1] = rgba[1]; out[p + 2] = rgba[2]; out[p + 3] = rgba[3];
+    }
+  }
+  return { width, height, data: out };
+}
+
+function boxBlurImage(imageData, radius) {
+  radius = Math.max(1, Math.round(radius));
+  const { width, height, data } = imageData;
+  const horizontal = new Float32Array(data.length);
+  const out = new Uint8ClampedArray(data.length);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      for (let ch = 0; ch < 3; ch++) {
+        let sum = 0, count = 0;
+        for (let dx = -radius; dx <= radius; dx++) {
+          const xx = x + dx;
+          if (xx < 0 || xx >= width) continue;
+          sum += data[(y * width + xx) * 4 + ch]; count++;
+        }
+        horizontal[(y * width + x) * 4 + ch] = sum / count;
+      }
+      horizontal[(y * width + x) * 4 + 3] = 255;
+    }
+  }
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const p = (y * width + x) * 4;
+      for (let ch = 0; ch < 3; ch++) {
+        let sum = 0, count = 0;
+        for (let dy = -radius; dy <= radius; dy++) {
+          const yy = y + dy;
+          if (yy < 0 || yy >= height) continue;
+          sum += horizontal[(yy * width + x) * 4 + ch]; count++;
+        }
+        out[p + ch] = sum / count;
+      }
+      out[p + 3] = 255;
+    }
+  }
+  return { width, height, data: out };
+}
+
+function perspectiveStress(imageData, severity) {
+  const { width, height } = imageData;
+  const inset = Math.min(width, height) * (0.025 + 0.11 * severity);
+  const source = [{ x: 0, y: 0 }, { x: width - 1, y: 0 }, { x: width - 1, y: height - 1 }, { x: 0, y: height - 1 }];
+  const destination = [
+    { x: inset * 1.15, y: inset * 0.25 },
+    { x: width - 1 - inset * 0.25, y: inset },
+    { x: width - 1 - inset * 1.0, y: height - 1 - inset * 0.35 },
+    { x: inset * 0.20, y: height - 1 - inset * 0.95 }
+  ];
+  const inverse = computeHomography(source, destination);
+  const out = new Uint8ClampedArray(width * height * 4);
+  out.fill(255);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const src = projectPoint(inverse, x, y);
+      if (src.x < 0 || src.y < 0 || src.x >= width || src.y >= height) continue;
+      const rgba = sampleRgbaBilinear(imageData, src.x, src.y);
+      const p = (y * width + x) * 4;
+      out[p] = rgba[0]; out[p + 1] = rgba[1]; out[p + 2] = rgba[2]; out[p + 3] = 255;
+    }
+  }
+  return { width, height, data: out };
+}
+
+/** Apply one deterministic camera/print-style distortion to ImageData. */
+function applyStressDistortion(imageData, type, severity = 0.5, options = {}) {
+  assert(imageData?.data && imageData.width && imageData.height, "applyStressDistortion requires ImageData-like input.");
+  const s = clampNumber(Number(severity), 0, 1);
+  if (type === "clean") return cloneImageDataLike(imageData);
+  if (type === "blur") return boxBlurImage(imageData, 1 + s * 2.2);
+  if (type === "perspective") return perspectiveStress(imageData, s);
+  if (type === "downscale") {
+    const scale = Math.max(0.20, 1 - s * 0.72);
+    const small = resizeImageDataLike(imageData, imageData.width * scale, imageData.height * scale);
+    return resizeImageDataLike(small, imageData.width, imageData.height);
+  }
+
+  const out = cloneImageDataLike(imageData);
+  const { width, height, data } = out;
+  const quantStep = 4 + Math.round(s * 30);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const p = (y * width + x) * 4;
+      for (let ch = 0; ch < 3; ch++) {
+        let value = data[p + ch];
+        if (type === "brightness-low") value *= 1 - s * 0.52;
+        else if (type === "brightness-high") value = value + (255 - value) * s * 0.48;
+        else if (type === "contrast-loss") value = 128 + (value - 128) * (1 - s * 0.48);
+        else if (type === "shadow") {
+          const nx = x / Math.max(1, width - 1);
+          const ny = y / Math.max(1, height - 1);
+          const shadow = clampNumber((nx * 0.65 + ny * 0.35 - 0.18) / 0.82, 0, 1);
+          value *= 1 - shadow * s * 0.62;
+        } else if (type === "jpeg") {
+          value = Math.round(value / quantStep) * quantStep;
+          const block = ((Math.floor(x / 8) + Math.floor(y / 8)) & 1) ? 1 : -1;
+          value += block * s * 3;
+        } else if (type === "warm") {
+          if (ch === 0) value *= 1 + s * 0.12;
+          if (ch === 2) value *= 1 - s * 0.22;
+        }
+        data[p + ch] = clampNumber(Math.round(value), 0, 255);
+      }
+      data[p + 3] = 255;
+    }
+  }
+  return out;
+}
+
+function runImageStressTest(imageData, expected = {}, options = {}) {
+  const profiles = options.profiles ?? STRESS_PROFILES;
+  const results = [];
+  let passedWeight = 0;
+  let totalWeight = 0;
+  for (const profile of profiles) {
+    const weight = Number(profile.weight ?? 1);
+    totalWeight += weight;
+    const distorted = applyStressDistortion(imageData, profile.type ?? profile.id, profile.severity ?? 0.5, profile);
+    const started = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+    try {
+      const decoded = scanImageData(distorted, {
+        minVersion: expected.version ?? options.minVersion ?? MIN_VERSION,
+        maxVersion: expected.version ?? options.maxVersion ?? MAX_VERSION,
+        debug: false
+      });
+      const matches = expected.crc32 == null || decoded.crc32 === expected.crc32;
+      if (matches) passedWeight += weight;
+      results.push({
+        id: profile.id,
+        label: profile.label,
+        type: profile.type,
+        severity: profile.severity,
+        passed: matches,
+        confidence: decoded.confidence ?? decoded.diagnostics?.confidence ?? null,
+        correctedSymbols: decoded.correctedSymbols ?? 0,
+        elapsedMs: (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - started,
+        image: options.includeImages ? distorted : undefined,
+        error: matches ? null : "Decoded payload did not match expected CRC."
+      });
+    } catch (error) {
+      results.push({
+        id: profile.id,
+        label: profile.label,
+        type: profile.type,
+        severity: profile.severity,
+        passed: false,
+        confidence: 0,
+        correctedSymbols: null,
+        elapsedMs: (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - started,
+        image: options.includeImages ? distorted : undefined,
+        error: error.message
+      });
+    }
+  }
+  const passPercent = totalWeight ? passedWeight / totalWeight * 100 : 0;
+  const averageConfidence = results.filter((r) => r.passed && Number.isFinite(r.confidence)).reduce((sum, r, _, arr) => sum + r.confidence / arr.length, 0);
+  const score = clampNumber(passPercent * 0.86 + averageConfidence * 100 * 0.14, 0, 100);
+  const rating = score >= 90 ? "Excellent" : score >= 75 ? "Good" : score >= 50 ? "Risky" : "Likely unscannable";
+  return {
+    score,
+    rating,
+    passPercent,
+    passed: results.filter((r) => r.passed).length,
+    total: results.length,
+    averageConfidence,
+    results
+  };
+}
+
+/** Render and run the standard scanability torture suite. */
+function assessScanability(code, renderOptions = {}, options = {}) {
+  assert(code?.matrix, "assessScanability expects an encoded QuadQR object.");
+  const testImageSize = Math.max(240, Math.min(Number(options.testImageSize ?? 480), Number(renderOptions.imageSize ?? 720)));
+  const image = renderToImageData(code, { ...renderOptions, imageSize: testImageSize });
+  const report = runImageStressTest(image, { version: code.version, crc32: code.crc32 }, options);
+  const autoLogoSize = renderOptions.logo ? estimateSafeLogoSize(code, renderOptions) : null;
+  return {
+    ...report,
+    version: code.version,
+    eccLevel: code.eccLevel,
+    utilization: code.utilization,
+    testImageSize,
+    autoLogoSize,
+    recommendations: [
+      ...(report.score < 75 ? ["Increase ECC, reduce logo size, use Classic style, or increase output/physical size."] : []),
+      ...(Number(renderOptions.quietZone ?? 4) < 4 ? ["Use a quiet zone of at least 4 modules for robust camera/print scanning."] : []),
+      ...(renderOptions.logo && autoLogoSize != null ? [`Auto-safe logo estimate: ${(autoLogoSize * 100).toFixed(1)}% of the symbol width.`] : []),
+      ...(normalizeRenderMode(renderOptions.mode ?? renderOptions.renderMode ?? "screen") === "print" ? getPrintGuidance(code, renderOptions).recommendations : [])
+    ]
+  };
+}
+
+function paletteConfidence(observedPalette) {
+  if (!observedPalette) return 0.5;
+  const values = ["black", "white", "red", "green", "blue"].map((name) => observedPalette[name]).filter(Boolean);
+  if (values.length < 5) return 0.5;
+  let minDistance = Infinity;
+  for (let i = 0; i < values.length; i++) {
+    for (let j = i + 1; j < values.length; j++) {
+      const a = values[i], b = values[j];
+      minDistance = Math.min(minDistance, Math.hypot(a.r - b.r, a.g - b.g, a.b - b.b));
+    }
+  }
+  return clampNumber((minDistance - 28) / 120, 0, 1);
+}
+
+function scannerDiagnostics(result, context = {}, options = {}) {
+  const info = result ? getVersionInfo(result.version, { ecc: result.eccLevel }) : null;
+  const correctableTotal = result && info
+    ? Number(info.correctableHeaderSymbols ?? 0) + Number(result.eccBlocks ?? 0) * Number(result.correctableSymbolsPerBlock ?? 0)
+    : 0;
+  const eccUtilization = correctableTotal > 0 ? clampNumber((result.correctedSymbols ?? 0) / correctableTotal, 0, 1) : 0;
+  const structureConfidence = clampNumber(
+    result?.structureScore ?? context.observations?.at(-1)?.structureScore ?? (result ? 0.92 : 0), 0, 1
+  );
+  const cellConfidence = clampNumber(result?.averageCellConfidence ?? 0.75, 0, 1);
+  const geometryConfidence = result
+    ? clampNumber(result.perspectiveCorrected ? Math.max(0.55, structureConfidence) : Math.max(0.65, structureConfidence * 0.9), 0, 1)
+    : (context.geometry?.length ? 0.45 : 0);
+  const calibrationConfidence = result
+    ? clampNumber(result.colorCalibrated ? paletteConfidence(result.observedPalette) : 0.55, 0, 1)
+    : 0;
+  const confidence = result
+    ? clampNumber(cellConfidence * 0.50 + structureConfidence * 0.20 + geometryConfidence * 0.15 + calibrationConfidence * 0.15 - eccUtilization * 0.12, 0, 1)
+    : 0;
+  const geometryCandidates = (context.geometry ?? []).slice(0, 8).map((geometry) => ({
+    version: geometry.version,
+    size: geometry.size,
+    score: geometry.score,
+    estimatedSize: geometry.estimatedSize,
+    alignmentScore: geometry.alignmentScore,
+    alignmentGridScore: geometry.alignmentGridScore,
+    corners: geometry.corners ?? geometry.quad ?? null,
+    finders: geometry.finders ?? null
+  }));
+  const observations = context.observations ?? [];
+  const latest = observations.at(-1) ?? null;
+  const stages = {
+    finderDetection: geometryCandidates.length > 0 || Boolean(result && !result.perspectiveCorrected),
+    geometry: geometryCandidates.length > 0 || Boolean(result && !result.perspectiveCorrected),
+    sampling: observations.length > 0 || Boolean(result),
+    colorClassification: observations.length > 0 || Boolean(result),
+    ecc: Boolean(result),
+    crc: Boolean(result),
+    payload: Boolean(result)
+  };
+  let failedStage = null;
+  if (!result) {
+    failedStage = !stages.finderDetection ? "finder-detection"
+      : !stages.sampling ? "perspective-geometry"
+        : "color-classification-or-ecc";
+  }
+  return {
+    confidence,
+    cellConfidence,
+    structureConfidence,
+    geometryConfidence,
+    calibrationConfidence,
+    eccUtilization,
+    correctedErrors: result?.correctedSymbols ?? 0,
+    erasureSymbols: result?.erasureSymbols ?? 0,
+    lowConfidenceCells: result?.lowConfidenceCells ?? latest?.lowConfidenceCells ?? null,
+    stages,
+    failedStage,
+    geometryCandidates,
+    vision: context.vision ?? null,
+    sampled: latest ? {
+      version: latest.version,
+      samplingMode: latest.samplingMode,
+      colorNormalization: latest.colorNormalization,
+      structureScore: latest.structureScore,
+      averageCellConfidence: latest.averageCellConfidence,
+      observedPalette: latest.observedPalette ?? null,
+      matrix: options.debugMatrices === false ? undefined : latest.matrix,
+      confidenceMatrix: options.debugMatrices === false ? undefined : latest.confidence
+    } : null
+  };
+}
+
+function decorateScanResult(result, context, options) {
+  const diagnostics = scannerDiagnostics(result, context, options);
+  return {
+    ...result,
+    confidence: diagnostics.confidence,
+    geometryConfidence: diagnostics.geometryConfidence,
+    calibrationConfidence: diagnostics.calibrationConfidence,
+    structureConfidence: diagnostics.structureConfidence,
+    correctedErrors: result.correctedSymbols ?? 0,
+    eccUtilization: diagnostics.eccUtilization,
+    diagnostics: options.debug ? diagnostics : {
+      confidence: diagnostics.confidence,
+      geometryConfidence: diagnostics.geometryConfidence,
+      calibrationConfidence: diagnostics.calibrationConfidence,
+      structureConfidence: diagnostics.structureConfidence,
+      eccUtilization: diagnostics.eccUtilization,
+      correctedErrors: diagnostics.correctedErrors,
+      erasureSymbols: diagnostics.erasureSymbols
+    }
+  };
+}
+
+/** Non-throwing scanner debug API with detailed stage diagnostics. */
+function debugScanImageData(imageData, options = {}) {
+  try {
+    const result = scanImageData(imageData, { ...options, debug: true });
+    return { ok: true, result, debug: result.diagnostics };
+  } catch (error) {
+    return { ok: false, error: error.message, debug: error.debug ?? null };
+  }
+}
+
 function scanImageData(imageData, options = {}) {
   assert(imageData && imageData.data && imageData.width && imageData.height, "Valid ImageData is required.");
   const minVersion = options.minVersion ?? MIN_VERSION;
@@ -4377,11 +6701,49 @@ function scanImageData(imageData, options = {}) {
   validateVersion(maxVersion);
 
   const geometryCollector = [];
-  const scanOptions = { ...options, _geometryCollector: geometryCollector };
+  const observationCollector = options.debug ? [] : (Array.isArray(options._observationCollector) ? options._observationCollector : []);
+  const visionDiagnostics = options.debug ? { passes: [] } : (options._visionDiagnostics ?? null);
+  const debugContext = { geometry: geometryCollector, observations: observationCollector, vision: visionDiagnostics };
+  const scanOptions = {
+    ...options,
+    _geometryCollector: geometryCollector,
+    _observationCollector: observationCollector,
+    _visionDiagnostics: visionDiagnostics
+  };
 
   if (options.perspective !== false) {
     const perspective = tryPerspectiveScan(imageData, scanOptions);
-    if (perspective) return perspective;
+    if (perspective) return decorateScanResult(perspective, debugContext, options);
+  }
+
+  // Triangle16 has half-cell color regions, so geometry that is adequate for
+  // solid RGBW cells can still be off by a few tenths of a module and mix the
+  // two triangle colors. If normal geometry was found but no payload decoded,
+  // retry geometry once with finer alignment localization. This stays off the
+  // clean/normal camera fast path.
+  if (
+    options.perspective !== false &&
+    options.preciseAlignmentRecovery !== false &&
+    !options._preciseAlignmentRecovery &&
+    geometryCollector.length > 0
+  ) {
+    try {
+      const precise = tryPerspectiveScan(imageData, {
+        ...scanOptions,
+        preciseAlignment: true,
+        _preciseAlignmentRecovery: true,
+        _diagnosticLabel: "precise-alignment"
+      });
+      if (precise) {
+        return decorateScanResult({
+          ...precise,
+          geometryRefined: true,
+          recoveryMode: precise.recoveryMode ?? "precise-alignment"
+        }, debugContext, options);
+      }
+    } catch {
+      // Continue to color recovery and axis-aligned fallback.
+    }
   }
 
   // If the normal scanner could see QuadQR geometry but could not decode the
@@ -4408,12 +6770,12 @@ function scanImageData(imageData, options = {}) {
         _geometryCollector: []
       });
       if (recovered) {
-        return {
+        return decorateScanResult({
           ...recovered,
           autoEnhanced: true,
           recoveryMode: "auto-tone-contrast-color",
           originalColorNormalization: recovered.colorNormalization
-        };
+        }, debugContext, options);
       }
     } catch {
       // Continue to the axis-aligned fallback.
@@ -4422,7 +6784,7 @@ function scanImageData(imageData, options = {}) {
 
   if (options.axisAlignedFallback !== false) {
     const axis = tryAxisAlignedScan(imageData, scanOptions);
-    if (axis) return axis;
+    if (axis) return decorateScanResult(axis, debugContext, options);
   }
 
   // Static images sometimes have such low contrast that locator detection itself
@@ -4449,20 +6811,22 @@ function scanImageData(imageData, options = {}) {
       };
       if (options.perspective !== false) {
         const perspective = tryPerspectiveScan(enhanced, recoveryOptions);
-        if (perspective) return { ...perspective, autoEnhanced: true, recoveryMode: "auto-tone-contrast-color" };
+        if (perspective) return decorateScanResult({ ...perspective, autoEnhanced: true, recoveryMode: "auto-tone-contrast-color" }, debugContext, options);
       }
       if (options.axisAlignedFallback !== false) {
         const axis = tryAxisAlignedScan(enhanced, recoveryOptions);
-        if (axis) return { ...axis, autoEnhanced: true, recoveryMode: "auto-tone-contrast-color" };
+        if (axis) return decorateScanResult({ ...axis, autoEnhanced: true, recoveryMode: "auto-tone-contrast-color" }, debugContext, options);
       }
     } catch {
       // Fall through to the normal scan failure below.
     }
   }
 
-  throw new Error(
+  const error = new Error(
     "No valid QuadQR code found. Try better lighting, fill more of the frame, keep all locator patterns visible, or use a less blurred image."
   );
+  if (options.debug) error.debug = scannerDiagnostics(null, debugContext, options);
+  throw error;
 }
 
 async function scanFile(file, options = {}) {
@@ -4785,6 +7149,7 @@ async function startCameraScanner(video, options = {}) {
 
   const scanInterval = Math.max(80, options.scanInterval ?? 180);
   const scratchCanvas = document.createElement("canvas");
+  const highResolutionCanvas = document.createElement("canvas");
   const multiFrameEnabled = options.multiFrame !== false;
   const multiFrameWindow = Math.max(2, Math.min(8, Math.round(options.multiFrameWindow ?? 4)));
   const multiFrameMinFrames = Math.max(2, Math.min(multiFrameWindow, Math.round(options.multiFrameMinFrames ?? 2)));
@@ -4792,6 +7157,12 @@ async function startCameraScanner(video, options = {}) {
   const cameraAutoColorEvery = Math.max(1, Math.round(options.cameraAutoColorEvery ?? 1));
   const cameraAutoEnhanceEvery = Math.max(1, Math.round(options.cameraAutoEnhanceEvery ?? 2));
   const cameraFinderRecoveryEvery = Math.max(1, Math.round(options.cameraFinderRecoveryEvery ?? 2));
+  const cameraHighResolutionEvery = Math.max(1, Math.round(options.cameraHighResolutionEvery ?? 2));
+  const baseCameraMaxDimension = Math.max(480, Math.round(options.maxDimension ?? 1080));
+  const cameraHighResolutionMaxDimension = Math.max(
+    baseCameraMaxDimension,
+    Math.round(options.cameraHighResolutionMaxDimension ?? 1600)
+  );
   let missStreak = 0;
   let stopped = false;
   let busy = false;
@@ -4838,7 +7209,7 @@ async function startCameraScanner(video, options = {}) {
 
   const scanNow = () => scanVideoFrame(video, {
     ...options,
-    maxDimension: options.maxDimension ?? 1080,
+    maxDimension: baseCameraMaxDimension,
     canvas: scratchCanvas
   });
 
@@ -4905,7 +7276,7 @@ async function startCameraScanner(video, options = {}) {
       busy = true;
       frameNumber++;
       const observations = [];
-      const frameDiagnostics = diagnosticsEnabled ? {} : null;
+      const frameDiagnostics = {};
       const capturedFrame = {};
       const frameStarted = nowMs();
       let allowAutoEnhance = false;
@@ -4933,7 +7304,7 @@ async function startCameraScanner(video, options = {}) {
           // If geometry exists, the rectified QR-only pixel enhancer is both
           // stronger and much cheaper than reprocessing the whole live frame.
           fullFrameAutoEnhanceRecovery: options.fullFrameAutoEnhanceRecovery ?? false,
-          maxDimension: options.maxDimension ?? 1080,
+          maxDimension: baseCameraMaxDimension,
           canvas: scratchCanvas,
           _capturedFrame: capturedFrame,
           _observationCollector: observations,
@@ -4974,6 +7345,71 @@ async function startCameraScanner(video, options = {}) {
           ...frameDiagnostics
         });
 
+        // Geometry-aware high-resolution retry. A dense QuadQR can look large
+        // enough in the preview while each individual module has become too
+        // small after the normal 1080 px scanner cap. If the fast pass already
+        // sees at least two convincing finders, spend one bounded retry on a
+        // higher-resolution copy of the visible camera ROI. Empty frames and
+        // ordinary small codes never pay this cost.
+        const shouldTryHighResolution = options.cameraHighResolutionRecovery !== false &&
+          cameraHighResolutionMaxDimension > baseCameraMaxDimension &&
+          (frameDiagnostics?.finderCount ?? 0) >= (options.cameraHighResolutionMinFinders ?? 2) &&
+          ((missStreak - 1) % cameraHighResolutionEvery === 0);
+        if (shouldTryHighResolution) {
+          const highResolutionObservations = [];
+          const highResolutionDiagnostics = {};
+          const highResolutionCapturedFrame = {};
+          emitDiagnostic({
+            type: "method",
+            state: "trying",
+            method: "high-resolution-geometry-recovery",
+            message: `Dense geometry detected · retrying at up to ${cameraHighResolutionMaxDimension}px`,
+            ...frameDiagnostics
+          });
+          try {
+            const recoveryStarted = nowMs();
+            const recovered = scanVideoFrame(video, {
+              ...options,
+              _diagnosticLabel: "high-resolution-geometry-recovery",
+              finderRecovery: true,
+              autoEnhanceRecovery: false,
+              fullFrameAutoEnhanceRecovery: false,
+              maxDimension: cameraHighResolutionMaxDimension,
+              canvas: highResolutionCanvas,
+              _capturedFrame: highResolutionCapturedFrame,
+              _observationCollector: highResolutionObservations,
+              _frameDiagnostics: highResolutionDiagnostics
+            });
+            const recoveryElapsedMs = nowMs() - recoveryStarted;
+            emitDiagnostic({
+              type: "success",
+              state: "decoded",
+              method: "high-resolution-geometry-recovery",
+              elapsedMs: recoveryElapsedMs,
+              message: `High-resolution retry decoded v${recovered.version} · ${Math.round(recoveryElapsedMs)} ms`,
+              ...(highResolutionDiagnostics ?? frameDiagnostics)
+            });
+            missStreak = 0;
+            observationHistory.clear();
+            if (emitResult({
+              ...recovered,
+              cameraHighResolutionRecovery: true,
+              cameraProgressiveRecovery: true,
+              recoveryMode: recovered.recoveryMode ?? "high-resolution-geometry-recovery"
+            }, highResolutionCapturedFrame, highResolutionDiagnostics ?? frameDiagnostics)) return;
+          } catch (highResolutionError) {
+            observations.push(...highResolutionObservations);
+            emitDiagnostic({
+              type: "method",
+              state: "failed",
+              method: "high-resolution-geometry-recovery",
+              message: `High-resolution geometry retry did not decode${highResolutionDiagnostics?.finderCount != null ? ` · ${highResolutionDiagnostics.finderCount} finder(s)` : ""}`,
+              error: highResolutionError?.message ?? String(highResolutionError),
+              ...(highResolutionDiagnostics ?? frameDiagnostics)
+            });
+          }
+        }
+
         // The user's real phone-camera case is dominated by color cast before
         // finder detection: Photoshop Auto Color alone makes the same live QR
         // immediately detectable. Retry the exact captured frame with a cheap
@@ -5278,11 +7714,14 @@ const internals = Object.freeze({
   HEADER_CODEWORD_CELLS,
   COMPACT_HEADER_CODEWORD_CELLS,
   CELLS_PER_BYTE,
+  RGBW_CELLS_PER_BYTE,
+  TRIANGLE16_CELLS_PER_BYTE,
+  TRIANGLE16_FLAG,
   TEXT_FLAG,
   SECURE_FLAG
 });
 
-return { installCrc32Accelerator, crc32, getVersionInfo, encodeText, encodeBytes, encodeSecureText, encodeSecureBytes, decryptDecoded, decodeMatrix, renderToCanvas, renderToImageData, scanImageData, scanFile, scanVideoFrame, startCameraScanner, rectifyDetectedCode, rotateMatrix, FORMAT_VERSION, MIN_VERSION, MAX_VERSION, DEFAULT_ECC_LEVEL, CELL, DEFAULT_PALETTE, RENDER_STYLES, ECC_LEVELS, internals, SECURITY_MODES, SECURITY_ALGORITHMS, SECURE_PAYLOAD_VERSION, DEFAULT_PBKDF2_ITERATIONS, generateRaw256Key, normalizeRaw256Key, bytesToHex };
+return { compressPayload, decompressPayload, deriveSigningKeyId, generateSigningKeyPair, installCrc32Accelerator, crc32, getVersionInfo, encodeText, encodeBytes, encodeUint8Array, encodeSignedBytes, encodeSignedText, encodeSecureText, encodeSecureBytes, decryptDecoded, decodeMatrix, decodeUint8Array, verifyDecodedSignature, estimateSafeLogoSize, findMaxSafeLogoSize, getPrintGuidance, renderToCanvas, renderToImageData, renderToSVG, applyStressDistortion, runImageStressTest, assessScanability, debugScanImageData, scanImageData, scanFile, scanVideoFrame, startCameraScanner, rectifyDetectedCode, rotateMatrix, FORMAT_VERSION, MIN_VERSION, MAX_VERSION, DEFAULT_ECC_LEVEL, RENDER_MODES, CELL_ENCODINGS, PRINT_PALETTE, COMPRESSION_MODES, SIGNATURE_ALGORITHMS, CELL, DEFAULT_PALETTE, RENDER_STYLES, ECC_LEVELS, STRESS_PROFILES, internals, SECURITY_MODES, SECURITY_ALGORITHMS, SECURE_PAYLOAD_VERSION, DEFAULT_PBKDF2_ITERATIONS, generateRaw256Key, normalizeRaw256Key, bytesToHex };
 })();
 const QuadQR = __qqr_quadqr_js;