quadqr-js 1.2.0 → 1.4.2

package/docs/RELIABILITY_LAB.md

@@ -0,0 +1,64 @@
+# Reliability Lab
+
+QuadQR includes a deterministic Reliability Lab for regression testing generated symbols against camera-style damage. It is intended for comparing scanner changes, render settings, ECC profiles, output size, and the experimental High Density Mode under repeatable conditions.
+
+The lab verifies the decoded payload CRC. Finding three locators is not counted as success unless the final payload is recovered correctly.
+
+## Browser demo
+
+Open the **Reliability Lab** tab after generating a QuadQR. The lab provides:
+
+- Quick, Full, and Extreme suites;
+- per-scenario pass/fail, confidence, Reed-Solomon correction count, and decode time;
+- category-level scoring for optics, lighting, color, resampling, sensor damage, and perspective;
+- a 3D perspective playground with X pitch, Y yaw, and Z rotation controls;
+- angle sweeps to find the largest tested pitch, yaw, or Z rotation that still decodes.
+
+X pitch and Y yaw simulate a code plane tilting in depth. Z rotation is an in-plane rotation. The controls can be combined.
+
+## Public API
+
+```js
+import {
+  applyStressDistortion,
+  runReliabilityLab,
+  runPerspectiveSweep
+} from "quadqr-js";
+
+const transformed = applyStressDistortion(imageData, "perspective-3d", 0.5, {
+  pitchDegrees: 20,
+  yawDegrees: 45,
+  rollDegrees: 15
+});
+
+const report = runReliabilityLab(imageData, {
+  version: encoded.version,
+  crc32: encoded.crc32
+}, {
+  suite: "full"
+});
+
+const sweep = runPerspectiveSweep(imageData, {
+  version: encoded.version,
+  crc32: encoded.crc32
+}, {
+  axis: "yaw",
+  angles: [0, 15, 25, 35, 45, 55]
+});
+```
+
+## Suites
+
+The Reliability Lab extends the smaller scanability suite with deterministic cases for lens blur, motion blur, low/high exposure, gradient shadow, glare, warm/cool color casts, contrast loss, sensor noise, JPEG-like damage, downscaling, projective skew, 3D pitch/yaw, Z rotation, and combined 3D tilt.
+
+The **Extreme** suite adds stronger perspective cases. These are deliberately demanding and may fail at low pixels-per-module even when the same angle succeeds at a larger rendered size.
+
+## Perspective scanner recovery
+
+The scanner keeps its normal fast path for ordinary frames. When locator scale differences indicate projective foreshortening, the geometry stage can perform a bounded coarse-to-fine search for the primary alignment reference. The fine stage uses denser sub-cell scoring so payload cells are less likely to impersonate the alignment marker. This improves steep-angle recovery without weakening normal structure checks globally.
+
+Distributed secondary alignment references are still used to validate the resulting homography.
+
+## Interpreting results
+
+Synthetic results are regression aids, not a substitute for real phone-camera and print testing. A useful practical metric is the largest reliable angle at the intended physical size and scanning distance, not only the theoretical bits per cell.

package/docs/TRIANGLE16.md

@@ -0,0 +1,98 @@
+# Triangle16 internals for High Density Mode
+
+Triangle16 is the experimental physical cell layout used internally by QuadQR **High Density Mode**. It keeps the existing QuadQR geometry, finder patterns, timing pattern, alignment patterns, calibration, Spectrum ECC, CRC, security envelope, compression, and signing behavior, but changes how payload data cells are represented.
+
+## Physical cell
+
+A Triangle16 payload cell is split by one fixed `/` diagonal:
+
+```text
++---------+
+| AAAAAA /|
+| AAAAA /B|
+| AAAA /BB|
+| AAA /BBB|
+| AA /BBBB|
+| A /BBBBB|
+| /BBBBBBB|
++---------+
+```
+
+`A` is the upper-left triangle and `B` is the lower-right triangle. Each triangle independently uses the existing RGBW alphabet:
+
+```text
+R = 00
+G = 01
+B = 10
+W = 11
+```
+
+The pair therefore has 16 states:
+
+```text
+R/R  R/G  R/B  R/W
+G/R  G/G  G/B  G/W
+B/R  B/G  B/B  B/W
+W/R  W/G  W/B  W/W
+```
+
+The first triangle carries the high 2 bits and the second triangle carries the low 2 bits. One Triangle16 body cell therefore carries 4 raw bits, so one byte occupies two body cells instead of four RGBW cells.
+
+## Protected header stays solid
+
+The protected bootstrap/header intentionally does not use mixed-color triangles. Its normal RGBW header cells are represented as same-color pairs such as `R/R`, `G/G`, `B/B`, and `W/W`.
+
+This uses four cells per protected header byte, exactly like RGBW, but makes it much easier for the decoder to recover the mode flag when the image is blurred, skewed, resized, or color-shifted. Header flag bit 6 declares Triangle16 for the ECC-protected body.
+
+## Scanner sampling
+
+The scanner does not sample the diagonal or the exact module center. Each triangle uses three protected interior sample anchors, robust aggregation, and a spatial-stability score. The weaker/less stable region lowers the cell confidence and supplies the first alternate state for Spectrum ECC 2.0 soft recovery.
+
+The normal image and camera scanner automatically attempts Triangle16 sampling. No separate scan mode is required. If ordinary finder/alignment geometry is good enough to locate the symbol but not precise enough to decode the half-cell regions, the scanner performs one bounded **precise-alignment recovery** pass. That pass uses denser alignment-pattern probes and a finer sub-module search, then retries the same dual-triangle classifier.
+
+## Rendering rules
+
+Triangle16 uses exact hard-edged triangular payload cells. Decorative payload styles are intentionally bypassed in this profile because rounded, inset, soft, or depth effects can reduce the usable sampling area or contaminate the diagonal boundary. Structural modules keep the normal QuadQR rendering behavior.
+
+PNG/ImageData, Canvas, SVG, browser, and Node rendering all support Triangle16.
+
+## API
+
+```js
+import { encodeText } from "quadqr-js";
+
+const code = encodeText("High-density QuadQR", {
+  ecc: "M",
+  highDensity: true
+});
+```
+
+High Density Mode is disabled by default. `Triangle16` is an internal/technical name for the current experimental physical layout, not a separate public mode selector.
+
+## Capacity
+
+Raw body density is:
+
+```text
+RGBW       4 states   2 bits/body cell
+Triangle16 16 states  4 bits/body cell
+```
+
+The protected header remains RGBW-equivalent, and ECC/CRC overhead is unchanged at the byte level, so usable payload capacity is close to but not exactly 2x for a fixed matrix version.
+
+Use `getVersionInfo(version, { ecc, highDensity: true })` or the demo capacity calculator for the exact value.
+
+## Reliability caveat
+
+Triangle16 doubles raw body bits per cell, but it also halves the spatial area available to each independently classified color. Its meaningful real-world metric is not only bits per matrix cell. It is reliable payload bytes at a fixed physical size, camera distance, angle, lighting condition, resize/compression pipeline, and print quality.
+
+The branch should therefore be stress-tested before treating Triangle16 as a stable format. Important cases include:
+
+- perspective and partial finder degradation;
+- defocus and motion blur;
+- low camera pixel coverage per module;
+- JPEG compression and repeated image resizing;
+- shadows, glare, white-balance shifts, and saturation changes;
+- cheap printing, ink spread, paper tint, and camera recapture.
+
+If full 16-state reliability becomes the limiting factor, a restricted triangle alphabet can be explored later without changing the basic physical-cell experiment.

package/docs/WASM.md

@@ -56,7 +56,7 @@ You can also provide WASM bytes directly through the `bytes` option.
 When the classic `quadqr.min.js` global build is loaded from a CDN, `QuadQR.initWasm()` resolves the bundled sibling WASM asset from the same package/version location.
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/quadqr-js@1.1.0/dist/quadqr.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/quadqr-js@1.4.1/dist/quadqr.min.js"></script>
 <script>
   await QuadQR.initWasm();
 </script>

package/package.json

@@ -1,34 +1,29 @@
 {
   "name": "quadqr-js",
-  "version": "1.2.0",
-  "description": "QuadQR: experimental four-state RGBW matrix code with Spectrum ECC, compression, Ed25519 signing, browser/Node scanning, diagnostics, stress testing, and optional AES-256-GCM security.",
+  "version": "1.4.2",
+  "description": "QuadQR: experimental RGBW matrix code with optional experimental High Density Mode, Spectrum ECC 2.0, multi-frame camera scanning, advanced calibration, Reliability Lab, and 3D perspective recovery.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "browser": "./dist/browser.js",
-  "types": "./types/index.d.ts",
   "unpkg": "./dist/quadqr.min.js",
   "jsdelivr": "./dist/quadqr.min.js",
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
       "default": "./dist/index.js"
     },
     "./browser": {
-      "types": "./types/index.d.ts",
       "import": "./dist/browser.js",
       "default": "./dist/browser.js"
     },
     "./node": {
-      "types": "./types/node.d.ts",
       "import": "./dist/node.js",
       "require": "./dist/node.cjs",
       "default": "./dist/node.js"
     },
     "./benchmark": {
-      "types": "./types/benchmark.d.ts",
       "import": "./dist/benchmark.js",
       "require": "./dist/benchmark.cjs",
       "default": "./dist/benchmark.js"
@@ -40,7 +35,6 @@
   },
   "files": [
     "dist",
-    "types",
     "bin",
     "docs",
     "FORMAT.md",
@@ -59,7 +53,8 @@
     "test": "node tests/self-test.js && node tests/package-test.js",
     "benchmark": "node scripts/benchmark.js",
     "pack:check": "npm run build && npm pack --dry-run",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm run build && npm test",
+    "test:demo": "node tests/demo-worker-test.js"
   },
   "engines": {
     "node": ">=20.19"
@@ -82,6 +77,8 @@
     "qr",
     "rgb",
     "rgbw",
+    "high-density",
+    "triangle16",
     "matrix-code",
     "barcode",
     "reed-solomon",
@@ -92,9 +89,13 @@
     "aes-gcm",
     "wasm",
     "compression",
+    "brotli",
     "ed25519",
     "scan-diagnostics",
-    "print-qr"
+    "print-qr",
+    "reliability-lab",
+    "perspective-correction",
+    "soft-decoding"
   ],
   "sideEffects": false
 }

package/types/benchmark.d.ts

@@ -1,8 +0,0 @@
-import type { EccLevel } from "./index.js";
-export const STANDARD_QR_BYTE_CAPACITY: Readonly<Record<EccLevel, readonly number[]>>;
-export function getStandardQrByteCapacity(version: number, ecc?: EccLevel): number;
-export function compareCapacity(version: number, ecc?: EccLevel): Record<string, number | string | null>;
-export function calculateCapacityPlan(options?: { payload?: string | Uint8Array; payloadBytes?: number; ecc?: EccLevel; compression?: "none" | "auto" | "lz"; signed?: boolean; keyId?: string; embedPublicKey?: boolean }): Record<string, unknown>;
-export function buildCapacityComparison(options?: { ecc?: EccLevel; versions?: number[] }): Array<Record<string, number | string | null>>;
-export function benchmarkCodec(options?: Record<string, unknown>): Record<string, unknown>;
-export function benchmarkReport(options?: Record<string, unknown>): Record<string, unknown>;

package/types/index.d.ts

@@ -1,375 +0,0 @@
-export type EccLevel = "L" | "M" | "Q" | "H";
-export type RenderStyle = "classic" | "depth" | "soft" | "inset";
-export type RenderMode = "screen" | "print";
-export type CompressionMode = "none" | "auto" | "lz";
-export type SecurityMode = "password" | "raw-key";
-
-export interface Palette {
-  black?: string;
-  white?: string;
-  red?: string;
-  green?: string;
-  blue?: string;
-}
-
-export interface EncodeOptions {
-  version?: number | "auto";
-  minVersion?: number;
-  maxVersion?: number;
-  ecc?: EccLevel;
-  maskId?: number;
-  text?: boolean;
-  compression?: CompressionMode;
-}
-
-export interface SigningOptions {
-  /** Private Ed25519 key used to create the signature. Never embed or distribute it. */
-  privateKey: CryptoKey | Uint8Array | ArrayBuffer;
-  /** Optional compact identifier stored with the signature so a verifier can select a trusted public key. */
-  keyId?: string;
-  /** Optional public key used only when embedPublicKey is explicitly enabled. */
-  publicKey?: CryptoKey | Uint8Array | ArrayBuffer;
-  /** Embed the public key for self-contained integrity checks. Default: false. */
-  embedPublicKey?: boolean;
-}
-
-export interface SignedEncodeOptions extends EncodeOptions, SigningOptions {}
-
-export interface PasswordSecurity {
-  mode: "password";
-  password: string;
-  iterations?: number;
-  keyId?: string | Uint8Array | false;
-}
-
-export interface RawKeySecurity {
-  mode: "raw-key";
-  key: string | Uint8Array | ArrayBuffer;
-  keyId?: string | Uint8Array | false;
-}
-
-export interface SecureEncodeOptions extends EncodeOptions {
-  security: PasswordSecurity | RawKeySecurity;
-  signing?: SigningOptions;
-}
-
-export interface QuadQRCode {
-  matrix: number[][];
-  version: number;
-  size: number;
-  formatVersion: number;
-  eccLevel: EccLevel;
-  payloadBytes: number;
-  capacityBytes: number;
-  secure?: boolean;
-  compressed?: boolean;
-  compression?: "none" | "lz";
-  signed?: boolean;
-  security?: SecurityMetadata | null;
-  [key: string]: unknown;
-}
-
-export interface SecurityMetadata {
-  securePayloadVersion?: number;
-  mode?: SecurityMode;
-  algorithm?: string;
-  kdf?: string | null;
-  iterations?: number | null;
-  keyId?: string | null;
-  keyIdHex?: string | null;
-  keyIdAuto?: boolean;
-  authenticated?: boolean;
-  decrypted?: boolean;
-  [key: string]: unknown;
-}
-
-export interface ScanDiagnostics {
-  confidence: number;
-  cellConfidence: number;
-  structureConfidence: number;
-  geometryConfidence: number;
-  calibrationConfidence: number;
-  eccUtilization: number;
-  correctedErrors: number;
-  erasureSymbols: number;
-  stages?: Record<string, boolean>;
-  failedStage?: string | null;
-  geometryCandidates?: unknown[];
-  sampled?: Record<string, unknown> | null;
-  [key: string]: unknown;
-}
-
-export interface DecodeResult {
-  payload: Uint8Array;
-  text: string | null;
-  version: number;
-  size: number;
-  formatVersion: number;
-  eccLevel: EccLevel;
-  secure: boolean;
-  requiresDecryption?: boolean;
-  decrypted?: boolean;
-  security?: SecurityMetadata | null;
-  encryptedPayload?: Uint8Array;
-  protectedPayload?: Uint8Array;
-  compressed?: boolean;
-  compression?: "none" | "lz";
-  signed?: boolean;
-  /** Legacy v1 signer label, if decoding an older signed symbol. */
-  signer?: string | null;
-  signingKeyId?: string | null;
-  hasEmbeddedPublicKey?: boolean;
-  signatureVerified?: boolean | null;
-  signatureTrusted?: boolean | null;
-  signatureTrustSource?: "external" | "embedded" | null;
-  confidence?: number;
-  geometryConfidence?: number;
-  calibrationConfidence?: number;
-  structureConfidence?: number;
-  correctedErrors?: number;
-  eccUtilization?: number;
-  diagnostics?: ScanDiagnostics;
-  [key: string]: unknown;
-}
-
-export interface ImageDataLike {
-  width: number;
-  height: number;
-  data: Uint8ClampedArray | Uint8Array;
-}
-
-export interface LogoRenderOptions {
-  /** Loaded CanvasImageSource in canvas rendering, ImageDataLike in pixel rendering, or URL/data URL in SVG rendering. */
-  source: CanvasImageSource | ImageDataLike | string;
-  /** Logo width/height as a fraction of the symbol area. Clamped to 0.05..0.30. Default: 0.18. */
-  size?: number | "auto";
-  /** Clear the modules behind the logo with a solid background before drawing it. */
-  clearBackground?: boolean;
-  /** Background padding around the logo in modules. Default: 0.65. */
-  padding?: number;
-  /** Rounded background corner radius in modules. Default: 0.8. */
-  radius?: number;
-  /** Background color used when clearBackground is enabled. Default: palette white. */
-  backgroundColor?: string;
-}
-
-export interface CameraFinderDiagnostic {
-  x: number;
-  y: number;
-  moduleSize: number;
-  confirmations?: number;
-  score?: number;
-}
-
-export interface CameraGeometryDiagnostic {
-  version: number;
-  size: number;
-  score: number;
-  estimatedSize?: number;
-  alignmentScore?: number;
-  alignmentGridScore?: number;
-  finders?: {
-    topLeft: CameraFinderDiagnostic;
-    topRight: CameraFinderDiagnostic;
-    bottomLeft: CameraFinderDiagnostic;
-  };
-  [key: string]: unknown;
-}
-
-export interface CameraDiagnosticEvent {
-  type: "camera-ready" | "frame" | "method" | "success" | string;
-  timestamp: number;
-  frame: number;
-  state?: "trying" | "miss" | "failed" | "decoded" | string;
-  method?: string;
-  message?: string;
-  elapsedMs?: number;
-  missStreak?: number;
-  scanWidth?: number;
-  scanHeight?: number;
-  frameWidth?: number;
-  frameHeight?: number;
-  scanRect?: { x: number; y: number; width: number; height: number };
-  finderCount?: number;
-  finders?: CameraFinderDiagnostic[];
-  finderMethod?: string | null;
-  finderPasses?: Array<{ method: string; finderCount: number; threshold?: number; geometryCount?: number }>;
-  geometry?: CameraGeometryDiagnostic | null;
-  [key: string]: unknown;
-}
-
-export interface RenderOptions {
-  /** Exact square output size in pixels. If neither imageSize nor moduleSize is supplied, defaults to 720. */
-  imageSize?: number;
-  /** Legacy/low-level pixels per module sizing. Used when imageSize is not supplied. */
-  moduleSize?: number;
-  quietZone?: number;
-  palette?: Palette;
-  style?: RenderStyle;
-  /** Screen defaults or print-safe palette/quiet-zone/classic-style behavior. */
-  mode?: RenderMode;
-  renderMode?: RenderMode;
-  allowStyledPrint?: boolean;
-  allowUnsafePrintQuietZone?: boolean;
-  logo?: CanvasImageSource | ImageDataLike | string | LogoRenderOptions;
-  logoSize?: number;
-  logoClearBackground?: boolean;
-  logoPadding?: number;
-  logoRadius?: number;
-  logoBackgroundColor?: string;
-  [key: string]: unknown;
-}
-
-export interface ScanOptions {
-  debug?: boolean;
-  debugMatrices?: boolean;
-  minVersion?: number;
-  maxVersion?: number;
-  perspective?: boolean;
-  axisAlignedFallback?: boolean;
-  maxDimension?: number;
-  sampleRadius?: number;
-  robustSampleRadius?: number;
-  adaptiveSampling?: boolean;
-  spatialColorNormalization?: boolean;
-  structureTolerance?: number;
-  maxErasureConfidence?: number;
-  geometryRefinement?: boolean;
-  finderRecovery?: boolean;
-  finderAutoColorBlackClip?: number;
-  finderAutoColorWhiteClip?: number;
-  finderAutoColorHighlightPercentile?: number;
-  finderAutoColorOutputHighlight?: number;
-  finderAutoColorAnalysisInset?: number;
-  finderAutoColorAnalysisInsets?: number[];
-  finderAutoColorMinimumInputRange?: number;
-  finderAutoColorTargetSamples?: number;
-  autoEnhanceRecovery?: boolean;
-  autoEnhanceWhenNoGeometry?: boolean;
-  autoEnhanceBlackClip?: number;
-  autoEnhanceWhiteClip?: number;
-  autoEnhanceSaturation?: number;
-  autoEnhanceTargetSamples?: number;
-  fullFrameAutoEnhanceRecovery?: boolean;
-  rectifiedAutoEnhanceRecovery?: boolean;
-  rectifiedRecoveryModuleSize?: number;
-  rectifiedRecoveryRadiusRatio?: number;
-  rectifiedAutoEnhanceBlackClip?: number;
-  rectifiedAutoEnhanceWhiteClip?: number;
-  rectifiedAutoEnhanceSaturation?: number;
-  rectifiedAutoEnhanceHighlightFraction?: number;
-  videoCropMode?: "visible" | "full";
-  videoObjectFit?: string;
-  videoObjectPosition?: string;
-  videoCropInset?: number;
-  refinementOffset?: number;
-  refinementStructureThreshold?: number;
-  refinementDecodeThreshold?: number;
-  refinementDecodeCandidates?: number;
-  [key: string]: unknown;
-}
-
-export interface CameraFrameMeta {
-  frame: number;
-  imageData: ImageDataLike;
-  scanWidth: number;
-  scanHeight: number;
-  sourceRect?: { x: number; y: number; width: number; height: number; cropped?: boolean } | null;
-  enhancedImageData?: ImageDataLike | null;
-  enhancedRect?: { x: number; y: number; width: number; height: number } | null;
-  enhancement?: { method?: string; cropInset?: number; analysisInset?: number; [key: string]: unknown } | null;
-  diagnostic?: Record<string, unknown> | null;
-}
-
-export interface CameraScanOptions extends ScanOptions {
-  scanInterval?: number;
-  stopOnResult?: boolean;
-  multiFrame?: boolean;
-  multiFrameWindow?: number;
-  multiFrameMinFrames?: number;
-  cameraAutoColorRecovery?: boolean;
-  cameraAutoColorEvery?: number;
-  cameraAutoColorBlackClip?: number;
-  cameraAutoColorWhiteClip?: number;
-  cameraAutoColorHighlightPercentile?: number;
-  cameraAutoColorOutputHighlight?: number;
-  cameraAutoColorAnalysisInset?: number;
-  cameraAutoColorAnalysisInsets?: number[];
-  cameraAutoColorCropInsets?: number[];
-  cameraAutoColorMinimumInputRange?: number;
-  cameraAutoColorTargetSamples?: number;
-  cameraAutoEnhanceEvery?: number;
-  cameraFinderRecoveryEvery?: number;
-  constraints?: MediaStreamConstraints;
-  onResult?: (result: DecodeResult, frame?: CameraFrameMeta | null) => void | Promise<void>;
-  onDecode?: (result: DecodeResult, frame?: CameraFrameMeta | null) => void | Promise<void>;
-  onScanMiss?: (error: Error) => void;
-  onDiagnostic?: (event: CameraDiagnosticEvent) => void;
-}
-
-export const FORMAT_VERSION: number;
-export const MIN_VERSION: number;
-export const MAX_VERSION: number;
-export const DEFAULT_ECC_LEVEL: EccLevel;
-export const RENDER_MODES: Readonly<{ SCREEN: "screen"; PRINT: "print" }>;
-export const PRINT_PALETTE: Readonly<Required<Palette>>;
-export const COMPRESSION_MODES: Readonly<Record<string, CompressionMode>>;
-export const SIGNATURE_ALGORITHMS: Readonly<{ ED25519: "Ed25519" }>;
-export const CELL: Readonly<{ BLACK: -1; RED: 0; GREEN: 1; BLUE: 2; WHITE: 3 }>;
-export const DEFAULT_PALETTE: Readonly<Required<Palette>>;
-export const RENDER_STYLES: Readonly<Record<string, RenderStyle>>;
-export const ECC_LEVELS: Readonly<Record<EccLevel, { id: number; paritySymbols: number; correctableSymbolsPerBlock: number }>>;
-export const SECURITY_MODES: Readonly<{ PASSWORD: "password"; RAW_KEY: "raw-key" }>;
-export const SECURITY_ALGORITHMS: Readonly<{ AES_256_GCM: "AES-256-GCM" }>;
-export const SECURE_PAYLOAD_VERSION: number;
-export const DEFAULT_PBKDF2_ITERATIONS: number;
-
-export function encodeText(text: string, options?: EncodeOptions): QuadQRCode;
-export function encodeBytes(input: Uint8Array | ArrayBuffer | ArrayLike<number>, options?: EncodeOptions): QuadQRCode;
-export function encodeUint8Array(input: Uint8Array | ArrayBuffer | ArrayLike<number>, options?: EncodeOptions): QuadQRCode;
-export function encodeSignedText(text: string, options: SignedEncodeOptions): Promise<QuadQRCode>;
-export function encodeSignedBytes(input: Uint8Array | ArrayBuffer | ArrayLike<number>, options: SignedEncodeOptions): Promise<QuadQRCode>;
-export function encodeSecureText(text: string, options: SecureEncodeOptions): Promise<QuadQRCode>;
-export function encodeSecureBytes(input: Uint8Array | ArrayBuffer | ArrayLike<number>, options: SecureEncodeOptions): Promise<QuadQRCode>;
-export function compressPayload(input: Uint8Array | ArrayBuffer | ArrayLike<number>): Uint8Array;
-export function decompressPayload(input: Uint8Array | ArrayBuffer | ArrayLike<number>, expectedLength?: number | null): Uint8Array;
-export function deriveSigningKeyId(publicKey: CryptoKey | Uint8Array | ArrayBuffer, bytes?: number): Promise<string>;
-export function generateSigningKeyPair(): Promise<{ privateKey: CryptoKey; publicKey: CryptoKey; privateKeyPkcs8: Uint8Array; publicKeyBytes: Uint8Array; keyId: string; algorithm: "Ed25519" }>;
-export function decodeMatrix(matrix: number[][], options?: Record<string, unknown>): DecodeResult;
-export function decodeUint8Array(matrix: number[][], options?: Record<string, unknown>): Uint8Array;
-export function decryptDecoded(result: DecodeResult, credentials: { password: string } | { key: string | Uint8Array | ArrayBuffer }): Promise<DecodeResult>;
-export function verifyDecodedSignature(result: DecodeResult, options?: {
-  publicKey?: CryptoKey | Uint8Array | ArrayBuffer;
-  trustedPublicKey?: CryptoKey | Uint8Array | ArrayBuffer;
-  trustedKeys?: Record<string, CryptoKey | Uint8Array | ArrayBuffer> | Map<string, CryptoKey | Uint8Array | ArrayBuffer>;
-  allowEmbeddedKey?: boolean;
-}): Promise<DecodeResult>;
-export function renderToCanvas(codeOrMatrix: QuadQRCode | number[][], canvas: HTMLCanvasElement, options?: RenderOptions): HTMLCanvasElement;
-export function renderToImageData(codeOrMatrix: QuadQRCode | number[][], options?: RenderOptions): ImageDataLike;
-export function renderToSVG(codeOrMatrix: QuadQRCode | number[][], options?: RenderOptions): string;
-export function estimateSafeLogoSize(codeOrMatrix: QuadQRCode | number[][], options?: RenderOptions & { ecc?: EccLevel; utilization?: number }): number;
-export function findMaxSafeLogoSize(code: QuadQRCode, options: RenderOptions & { minSize?: number; maxSize?: number; iterations?: number }): { safeSize: number; testedMax: number; iterations: number; empirical: boolean };
-export function getPrintGuidance(codeOrMatrix: QuadQRCode | number[][], options?: { quietZone?: number; physicalSizeMm?: number; dpi?: number; minimumModuleMm?: number }): Record<string, unknown>;
-export function scanImageData(imageData: ImageDataLike, options?: ScanOptions): DecodeResult;
-export function debugScanImageData(imageData: ImageDataLike, options?: ScanOptions): { ok: boolean; result?: DecodeResult; error?: string; debug?: ScanDiagnostics | null };
-export function scanFile(file: Blob, options?: ScanOptions): Promise<DecodeResult>;
-export function scanVideoFrame(video: HTMLVideoElement, options?: ScanOptions): DecodeResult;
-export function startCameraScanner(video: HTMLVideoElement, options?: CameraScanOptions): Promise<{ stop(): void; scanNow(): DecodeResult; stream: MediaStream; video: HTMLVideoElement }>;
-export function applyStressDistortion(imageData: ImageDataLike, type: string, severity?: number, options?: Record<string, unknown>): ImageDataLike;
-export const STRESS_PROFILES: readonly Readonly<{ id: string; label: string; type: string; severity: number; weight: number }>[];
-export function runImageStressTest(imageData: ImageDataLike, expected?: { version?: number; crc32?: number }, options?: Record<string, unknown>): Record<string, unknown>;
-export function assessScanability(code: QuadQRCode, renderOptions?: RenderOptions, options?: Record<string, unknown>): Record<string, unknown>;
-export function rectifyDetectedCode(imageData: ImageDataLike, options?: Record<string, unknown>): ImageDataLike;
-export function rotateMatrix(matrix: number[][], quarterTurns?: number): number[][];
-export function getVersionInfo(version: number, options?: { ecc?: EccLevel }): Record<string, unknown>;
-export function crc32(bytes: Uint8Array): number;
-export function installCrc32Accelerator(accelerator?: ((bytes: Uint8Array) => number) | null): void;
-export function generateRaw256Key(): Uint8Array;
-export function normalizeRaw256Key(key: string | Uint8Array | ArrayBuffer): Uint8Array;
-export function bytesToHex(bytes: Uint8Array): string;
-
-export function initWasm(options?: { url?: string | URL; bytes?: Uint8Array | ArrayBuffer }): Promise<{ enabled: true; module: string; accelerators: readonly string[]; bytes: number }>;
-export function getWasmState(): { enabled: true; module: string; accelerators: readonly string[]; bytes: number } | null;
-export function disableWasm(): void;
-
-export const internals: Readonly<Record<string, unknown>>;

package/types/node.d.ts

@@ -1,11 +0,0 @@
-export * from "./index.js";
-import type { DecodeResult, ImageDataLike, QuadQRCode, RenderOptions, ScanOptions } from "./index.js";
-
-export function decodePNG(input: Uint8Array | ArrayBuffer): ImageDataLike;
-export function encodePNG(imageData: ImageDataLike, options?: { compressionLevel?: number }): Buffer;
-export function toPNG(codeOrMatrix: QuadQRCode | number[][], options?: RenderOptions & { compressionLevel?: number }): Buffer;
-export function savePNG(codeOrMatrix: QuadQRCode | number[][], filename: string | URL, options?: RenderOptions & { compressionLevel?: number }): Promise<{ filename: string | URL; bytes: number }>;
-export function toSVG(codeOrMatrix: QuadQRCode | number[][], options?: RenderOptions): string;
-export function saveSVG(codeOrMatrix: QuadQRCode | number[][], filename: string | URL, options?: RenderOptions): Promise<{ filename: string | URL; bytes: number }>;
-export function scanBuffer(input: Uint8Array | ArrayBuffer, options?: ScanOptions): Promise<DecodeResult>;
-export function scanFile(filename: string | URL, options?: ScanOptions): Promise<DecodeResult>;