@sythos/js_barcode_universal 1.2.5 → 1.4.1

package/src/frameqr/detector.js

@@ -0,0 +1,193 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * Detector for the non-certified FrameQR Code profile.
+ *
+ * The profile deliberately reuses QR Model 2 geometry. Finder localisation and
+ * projective sampling therefore use the QR detector; the additional profile
+ * check is the light canvas signature. A sampled image cannot carry the
+ * encoder's in-memory marker, so the detector reconstructs the expected
+ * metadata, verifies that every reserved canvas module is light, and only then
+ * opts into the profile decoder. This rejects ordinary QR symbols whose centre
+ * merely happens to contain a plausible payload.
+ *
+ * Detection is verified for clean binarized rasters, integer scaling, quiet
+ * zones, and in-plane quarter turns. Arbitrary photographic perspective is not
+ * claimed by this module.
+ *
+ * @module frameqr/detector
+ */
+
+import { NotFoundError } from '../core/errors.js';
+import { sampleQuad } from '../image/grid-sampler.js';
+import { detectQR } from '../qr/detector.js';
+import { decodeFrameQR } from './decoder.js';
+import {
+  FRAMEQR_PROFILE,
+  canvasModules,
+  normalizeCanvasSpec,
+} from './tables.js';
+
+/** @typedef {{x:number, y:number}} Point */
+
+/** @typedef {object} FrameQRDetection
+ * @property {Point[]} corners Outer corners in reading order.
+ * @property {number} dimension QR modules per side.
+ * @property {number} version QR Model 2 version.
+ * @property {number} moduleSize Estimated pixels per module.
+ * @property {number} rotation Clockwise in-plane orientation in degrees.
+ * @property {BitMatrix} matrix Rectified profile matrix.
+ * @property {object} canvas Normalized canvas specification.
+ * @property {string} profile Profile identifier.
+ * @property {false} certified Always false for this implementation.
+ */
+
+function orientationDegrees(corners) {
+  const [tl, tr] = corners;
+  const angle = Math.atan2(tr.y - tl.y, tr.x - tl.x) * 180 / Math.PI;
+  return ((Math.round(angle / 90) * 90) % 360 + 360) % 360;
+}
+/**
+ * Return the number of canvas modules that are dark in a sampled matrix.
+ *
+ * Encoded profile symbols clear the whole reserved canvas. A non-zero count
+ * means either a normal QR symbol or a raster whose canvas was overwritten by
+ * artwork; both are rejected because decoding that image would be speculative.
+ */
+function canvasDarkCount(matrix, canvas) {
+  let dark = 0;
+  for (const [x, y] of canvasModules(matrix.width, canvas)) {
+    if (matrix.get(x, y)) dark++;
+  }
+  return dark;
+}
+
+function sameCandidate(left, right) {
+  if (left.dimension !== right.dimension) return false;
+  const a = left.corners[0];
+  const b = right.corners[0];
+  return Math.hypot(a.x - b.x, a.y - b.y) <= Math.max(left.moduleSize, right.moduleSize) * 2;
+}
+
+/**
+ * Detect FrameQR Code symbols in a binarized raster.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @param {object} [options]
+ * @param {object} [options.canvas] Explicit canvas metadata for non-default
+ *   shapes/size. Without it, the profile's canonical centered square is used.
+ * @param {boolean} [options.voting=false] Use majority sampling per module.
+ * @returns {FrameQRDetection[]} Best candidate first; empty when no verified
+ *   profile signature is found.
+ */
+export function detectFrameQR(binaryImage, options = {}) {
+  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+    throw new NotFoundError('detectFrameQR: no image supplied');
+  }
+
+  let candidates;
+  try { candidates = detectQR(binaryImage); } catch { return []; }
+  const detections = [];
+
+  for (const candidate of candidates) {
+    // QR detector dimensions are already constrained to legal Model 2 sizes.
+    let canvas;
+    try { canvas = normalizeCanvasSpec(candidate.dimension, options.canvas); }
+    catch { continue; }
+
+    for (const voting of [Boolean(options.voting), !Boolean(options.voting)]) {
+      let matrix;
+      try { matrix = sampleQuad(binaryImage, candidate.dimension, candidate.corners, voting); }
+      catch { continue; }
+
+      // The signature check is intentionally strict. It prevents an ordinary
+      // QR symbol from being relabelled as Canvas QR by the decoder's explicit
+      // allowUnmarked escape hatch.
+      if (canvasDarkCount(matrix, canvas) !== 0) continue;
+
+      const marked = matrix;
+      marked.frameqr = {
+        profile: FRAMEQR_PROFILE.id,
+        certified: false,
+        canvas,
+      };
+      let decoded;
+      try {
+        decoded = decodeFrameQR(marked, {
+          profile: FRAMEQR_PROFILE.id,
+          canvas,
+          allowUnmarked: true,
+        });
+      } catch { continue; }
+
+      const detection = {
+        corners: candidate.corners,
+        dimension: candidate.dimension,
+        version: candidate.version,
+        moduleSize: candidate.moduleSize,
+        rotation: orientationDegrees(candidate.corners),
+        matrix: marked,
+        canvas,
+        profile: FRAMEQR_PROFILE.id,
+        certified: false,
+        result: decoded,
+      };
+      if (!detections.some((entry) => sameCandidate(entry, detection))) detections.push(detection);
+      break;
+    }
+  }
+
+  detections.sort((a, b) => b.moduleSize - a.moduleSize);
+  return detections;
+}
+
+/**
+ * Detect and decode all verified Canvas QR symbols in one call.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @param {object} [options]
+ * @returns {Array<object>}
+ */
+export function detectAndDecodeFrameQR(binaryImage, options = {}) {
+  let detections;
+  try { detections = detectFrameQR(binaryImage, options); } catch { return []; }
+  const results = [];
+  const seen = new Set();
+  for (const detection of detections) {
+    const result = detection.result;
+    const key = `${result.version}|${result.text}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({ ...result, corners: detection.corners, rotation: detection.rotation });
+  }
+  return results;
+}

package/src/frameqr/encoder.js

@@ -0,0 +1,157 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * FrameQR Code encoder.
+ *
+ * This encoder deliberately builds on this project's QR Code implementation
+ * and then removes a conservatively bounded set of data modules for artwork.
+ * It is not an implementation of DENSO FrameQR and makes no interoperability
+ * claim for that proprietary format.
+ *
+ * @module frameqr/encoder
+ */
+
+import { EncodeError } from '../core/errors.js';
+import { encodeQR } from '../qr/encoder.js';
+import {
+  FRAMEQR_PROFILE,
+  canvasModules,
+  normalizeCanvasSpec,
+  validateCanvasSpec,
+} from './tables.js';
+
+/**
+ * @typedef {object} FrameQrEncodeOptions
+ * @property {'H'} [ecc] The profile always uses QR error correction H.
+ * @property {number} [version] Force a QR version 1-40.
+ * @property {number} [mask] Force a QR mask 0-7.
+ * @property {'auto'|'utf-8'|'iso-8859-1'} [charset] Byte mode interpretation.
+ * @property {boolean} [kanji] Allow QR kanji mode.
+ * @property {object} [canvas] Profile artwork reservation.
+ */
+
+function versionFor(matrix) {
+  return (matrix.width - 17) / 4;
+}
+
+function clearCanvas(matrix, modules) {
+  for (const [x, y] of modules) matrix.unset(x, y);
+}
+
+/**
+ * Encode a QR Code with a conservative artwork canvas according to the
+ * non-certified FrameQR Code profile.
+ *
+ * The profile forces QR H error correction and rejects a canvas whenever its
+ * known codeword damage exceeds the per-block correction budget. When a
+ * version is not forced, the smallest QR version that holds both payload and
+ * safe canvas is selected. A decoder can reconstruct the reserved modules from
+ * the returned profile metadata.
+ *
+ * @param {string} text
+ * @param {FrameQrEncodeOptions} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix}
+ * @throws {EncodeError} When the QR payload/options are invalid or the canvas
+ *   cannot safely fit the selected QR version.
+ */
+export function encodeFrameQR(text, options = {}) {
+  if (typeof text !== 'string') {
+    throw new EncodeError('FrameQR Code: text must be a string');
+  }
+  if (options.ecc !== undefined && options.ecc !== 'H') {
+    throw new EncodeError('FrameQR Code: ecc is fixed to H for this profile');
+  }
+
+  const qrOptions = {
+    mask: options.mask,
+    charset: options.charset,
+    kanji: options.kanji,
+    ecc: 'H',
+  };
+  for (const key of Object.keys(qrOptions)) {
+    if (qrOptions[key] === undefined) delete qrOptions[key];
+  }
+
+  const versions = options.version === undefined
+    ? Array.from({ length: 40 }, (_, index) => index + 1)
+    : [options.version];
+  let capacityError = null;
+  let unsafeAnalysis = null;
+  let selected = null;
+
+  for (const version of versions) {
+    let matrix;
+    try {
+      matrix = encodeQR(text, { ...qrOptions, version });
+    } catch (error) {
+      capacityError = error;
+      continue;
+    }
+
+    let canvas;
+    let analysis;
+    try {
+      canvas = normalizeCanvasSpec(matrix.width, options.canvas);
+      analysis = validateCanvasSpec(versionFor(matrix), canvas);
+    } catch (error) {
+      if (error instanceof EncodeError) throw error;
+      throw new EncodeError(`FrameQR Code: invalid canvas: ${error.message}`);
+    }
+    if (!analysis.safe) {
+      unsafeAnalysis = analysis;
+      continue;
+    }
+    selected = { matrix, canvas };
+    break;
+  }
+
+  if (!selected) {
+    if (unsafeAnalysis) {
+      throw new EncodeError(
+        'FrameQR Code: canvas is not safe for the selected QR version; ' +
+        `it touches ${unsafeAnalysis.touchedCodewordCount} codewords and has ` +
+        `a per-block correction budget of ${unsafeAnalysis.correctionBudgetPerBlock}`
+      );
+    }
+    if (capacityError) throw capacityError;
+    throw new EncodeError('FrameQR Code: unable to select a QR version');
+  }
+
+  const { matrix, canvas } = selected;
+  clearCanvas(matrix, canvasModules(matrix.width, canvas));
+  matrix.frameqr = {
+    profile: FRAMEQR_PROFILE.id,
+    certified: false,
+    canvas,
+  };
+  return matrix;
+}

package/src/frameqr/index.js

@@ -0,0 +1,43 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+export { encodeFrameQR } from './encoder.js';
+export { decodeFrameQR } from './decoder.js';
+export { detectFrameQR, detectAndDecodeFrameQR } from './detector.js';
+export {
+  FRAMEQR_PROFILE,
+  FRAMEQR_CANVAS_SHAPES,
+  canvasModules,
+  normalizeCanvasSpec,
+  analyzeCanvasDamage,
+  validateCanvasSpec,
+  validateFrameQrTables,
+} from './tables.js';

package/src/frameqr/tables.js

@@ -0,0 +1,271 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * Structural contract for FrameQR Code.
+ *
+ * DENSO WAVE's public material describes FrameQR(R) as a proprietary symbol
+ * with a freely shaped canvas, dedicated generation/reading software and no
+ * compatibility with ordinary QR readers. It does not publish the bitstream,
+ * placement or error-correction rules required for an interoperable encoder.
+ * Consequently this module does not claim to implement DENSO FrameQR.
+ *
+ * The implementable profile below starts with an ISO/IEC 18004 QR Model 2
+ * symbol at level H and clears a bounded group of data modules. Its worst-case
+ * damage is calculated per Reed-Solomon block and must remain within the
+ * standard QR correction radius. Function modules are never canvas modules.
+ * This provides a deterministic, independently testable FrameQR Code profile, but
+ * it is explicitly non-certified and not a substitute for proprietary FrameQR
+ * generation or validation software.
+ *
+ * @module frameqr/tables
+ */
+
+import {
+  blockLayout,
+  dataModuleOrder,
+  reservedModules,
+  versionSize,
+} from '../qr/tables.js';
+
+/** Public identity and compatibility boundary of the implementable profile. */
+export const FRAMEQR_PROFILE = Object.freeze({
+  id: 'sythos-canvas-qr/1',
+  name: 'FrameQR Code',
+  certified: false,
+  densoFrameQrCompatible: false,
+  baseSymbology: 'QR Code Model 2',
+  requiredEcc: 'H',
+  standard: 'ISO/IEC 18004 QR Code baseline',
+});
+
+/** Canvas shapes whose module membership is fully deterministic. */
+export const FRAMEQR_CANVAS_SHAPES = Object.freeze(['square', 'circle', 'diamond']);
+
+function oddAtMost(value, maximum) {
+  let n = Math.max(1, Math.min(maximum, Math.floor(value)));
+  if ((n & 1) === 0) n--;
+  return Math.max(1, n);
+}
+
+function assertSymbolSize(symbolSize) {
+  if (!Number.isInteger(symbolSize) || symbolSize < 21 || symbolSize > 177 || (symbolSize - 17) % 4 !== 0) {
+    throw new RangeError(`FrameQR Code: ${symbolSize} is not a QR Model 2 symbol size`);
+  }
+}
+
+/**
+ * Canonicalise a canvas request.
+ *
+ * Coordinates and dimensions are module units. Odd dimensions make the centre
+ * unambiguous. Only quarter turns are accepted because arbitrary-angle raster
+ * membership would depend on renderer-specific sampling.
+ *
+ * @param {number} symbolSize QR module width/height (21..177).
+ * @param {object} [canvas]
+ * @returns {{shape:string,centerX:number,centerY:number,width:number,height:number,angle:number}}
+ */
+export function normalizeCanvasSpec(symbolSize, canvas = {}) {
+  assertSymbolSize(symbolSize);
+  if (canvas === null || typeof canvas !== 'object' || Array.isArray(canvas)) {
+    throw new TypeError('FrameQR Code: canvas must be an object');
+  }
+
+  const shape = String(canvas.shape ?? 'square').toLowerCase();
+  if (!FRAMEQR_CANVAS_SHAPES.includes(shape)) {
+    throw new RangeError(`FrameQR Code: unsupported canvas shape "${shape}"`);
+  }
+
+  const defaultSize = oddAtMost(Math.max(3, Math.round(symbolSize * 0.17)), symbolSize - 16);
+  const requestedSize = canvas.size;
+  const requestedWidth = canvas.width ?? requestedSize ?? defaultSize;
+  const requestedHeight = canvas.height ?? requestedSize ?? defaultSize;
+  const maximumDimension = symbolSize - 16;
+  for (const [name, value] of [['width', requestedWidth], ['height', requestedHeight]]) {
+    if (!Number.isFinite(Number(value)) || Number(value) < 1 || Number(value) > maximumDimension) {
+      throw new RangeError(
+        `FrameQR Code: canvas ${name} must be between 1 and ${maximumDimension} modules`
+      );
+    }
+  }
+  const width = oddAtMost(Number(requestedWidth), maximumDimension);
+  const height = oddAtMost(Number(requestedHeight), maximumDimension);
+  const centerX = Math.round(canvas.centerX ?? (symbolSize - 1) / 2);
+  const centerY = Math.round(canvas.centerY ?? (symbolSize - 1) / 2);
+  const angle = ((Number(canvas.angle ?? 0) % 360) + 360) % 360;
+
+  if (![0, 90, 180, 270].includes(angle)) {
+    throw new RangeError('FrameQR Code: angle must be 0, 90, 180 or 270 degrees');
+  }
+  if (centerX < 8 || centerY < 8 || centerX >= symbolSize - 8 || centerY >= symbolSize - 8) {
+    throw new RangeError('FrameQR Code: canvas centre must remain inside the finder-pattern boundary');
+  }
+
+  return { shape, centerX, centerY, width, height, angle };
+}
+
+/**
+ * Enumerate canvas modules, including any overlaps with QR function modules.
+ * A conforming encoder rejects such overlaps rather than damaging function
+ * patterns.
+ *
+ * @param {number} symbolSize
+ * @param {object} [canvas]
+ * @returns {Array<[number, number]>}
+ */
+export function canvasModules(symbolSize, canvas = {}) {
+  const spec = normalizeCanvasSpec(symbolSize, canvas);
+  const rotate = spec.angle === 90 || spec.angle === 270;
+  const width = rotate ? spec.height : spec.width;
+  const height = rotate ? spec.width : spec.height;
+  const halfWidth = (width - 1) / 2;
+  const halfHeight = (height - 1) / 2;
+  const modules = [];
+
+  for (let dy = -halfHeight; dy <= halfHeight; dy++) {
+    for (let dx = -halfWidth; dx <= halfWidth; dx++) {
+      const nx = halfWidth === 0 ? 0 : dx / halfWidth;
+      const ny = halfHeight === 0 ? 0 : dy / halfHeight;
+      let inside;
+      if (spec.shape === 'circle') inside = nx * nx + ny * ny <= 1 + Number.EPSILON;
+      else if (spec.shape === 'diamond') inside = Math.abs(nx) + Math.abs(ny) <= 1 + Number.EPSILON;
+      else inside = true;
+      if (inside) modules.push([spec.centerX + dx, spec.centerY + dy]);
+    }
+  }
+  return modules;
+}
+
+/** Build the interleaved-codeword to RS-block map used by QR Model 2. */
+function codewordBlockMap(layout) {
+  const dataCounts = new Array(layout.blockCount);
+  for (let block = 0; block < layout.blockCount; block++) {
+    dataCounts[block] = block < layout.group1Blocks
+      ? layout.group1DataCount
+      : layout.group2DataCount;
+  }
+
+  const map = [];
+  const maxData = Math.max(...dataCounts);
+  for (let i = 0; i < maxData; i++) {
+    for (let block = 0; block < layout.blockCount; block++) {
+      if (i < dataCounts[block]) map.push(block);
+    }
+  }
+  for (let i = 0; i < layout.eccPerBlock; i++) {
+    for (let block = 0; block < layout.blockCount; block++) map.push(block);
+  }
+  return map;
+}
+
+/**
+ * Calculate worst-case QR codeword damage caused by a canvas.
+ * A codeword is counted if any of its modules is touched. This is conservative:
+ * clearing an already-light module does no damage, but safety cannot depend on
+ * one payload or mask.
+ *
+ * @param {number} version QR version 1..40.
+ * @param {object} [canvas]
+ */
+export function analyzeCanvasDamage(version, canvas = {}) {
+  if (!Number.isInteger(version) || version < 1 || version > 40) {
+    throw new RangeError(`FrameQR Code: version must be an integer 1-40, got ${version}`);
+  }
+  const symbolSize = versionSize(version);
+  const spec = normalizeCanvasSpec(symbolSize, canvas);
+  const modules = canvasModules(symbolSize, spec);
+  const reserved = reservedModules(version);
+  const reservedOverlaps = modules.filter(([x, y]) => reserved.get(x, y));
+
+  const moduleKeys = new Set(modules.map(([x, y]) => `${x},${y}`));
+  const order = dataModuleOrder(version);
+  const touchedCodewords = new Set();
+  for (let bit = 0; bit < order.length / 2; bit++) {
+    if (moduleKeys.has(`${order[bit * 2]},${order[bit * 2 + 1]}`)) touchedCodewords.add(bit >> 3);
+  }
+
+  const layout = blockLayout(version, 'H');
+  const blockMap = codewordBlockMap(layout);
+  const touchedByBlockSets = Array.from({ length: layout.blockCount }, () => new Set());
+  for (const codeword of touchedCodewords) {
+    const block = blockMap[codeword];
+    if (block !== undefined) touchedByBlockSets[block].add(codeword);
+  }
+  const touchedCodewordsByBlock = touchedByBlockSets.map((set) => set.size);
+  const correctionBudgetPerBlock = Math.floor(layout.eccPerBlock / 2);
+  const safe = reservedOverlaps.length === 0 &&
+    touchedCodewordsByBlock.every((count) => count <= correctionBudgetPerBlock);
+
+  return {
+    profile: FRAMEQR_PROFILE.id,
+    certified: false,
+    version,
+    symbolSize,
+    canvas: spec,
+    canvasModuleCount: modules.length,
+    reservedOverlaps,
+    touchedCodewordCount: touchedCodewords.size,
+    touchedCodewordsByBlock,
+    correctionBudgetPerBlock,
+    safe,
+  };
+}
+
+/** Validate a canvas and return the non-certifying structural analysis. */
+export function validateCanvasSpec(version, canvas = {}) {
+  return analyzeCanvasDamage(version, canvas);
+}
+
+/** Self-check the fixed profile contract and representative QR geometries. */
+export function validateFrameQrTables() {
+  const problems = [];
+  if (FRAMEQR_PROFILE.certified !== false || FRAMEQR_PROFILE.densoFrameQrCompatible !== false) {
+    problems.push('profile compatibility boundary must remain explicitly non-certified');
+  }
+  if (new Set(FRAMEQR_CANVAS_SHAPES).size !== FRAMEQR_CANVAS_SHAPES.length) {
+    problems.push('canvas shape identifiers must be unique');
+  }
+  for (const version of [1, 2, 3, 4, 7, 10, 20, 30, 40]) {
+    const size = versionSize(version);
+    const spec = normalizeCanvasSpec(size);
+    const modules = canvasModules(size, spec);
+    const unique = new Set(modules.map(([x, y]) => `${x},${y}`));
+    if (unique.size !== modules.length) problems.push(`v${version}: duplicate canvas modules`);
+    if (modules.some(([x, y]) => x < 0 || y < 0 || x >= size || y >= size)) {
+      problems.push(`v${version}: canvas escapes the symbol`);
+    }
+    const analysis = analyzeCanvasDamage(version, spec);
+    if (analysis.touchedCodewordsByBlock.length !== blockLayout(version, 'H').blockCount) {
+      problems.push(`v${version}: damage analysis block count mismatch`);
+    }
+  }
+  return problems;
+}

package/src/image/binarizer.js

@@ -23,6 +23,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
  * SPDX-License-Identifier: MIT
  *
  * Original work. No code from any other barcode implementation.

package/src/image/grid-sampler.js

@@ -23,6 +23,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
  * SPDX-License-Identifier: MIT
  *
  * Original work. No code from any other barcode implementation.

package/src/image/index.js

@@ -23,6 +23,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  *
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
  * SPDX-License-Identifier: MIT
  *
  * Original work. No code from any other barcode implementation.