Upload 37 files

Dockerfile

@@ -0,0 +1,40 @@
+FROM node:22-slim AS builder
+
+# Install FFmpeg for server-side video processing
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy package files and install dependencies
+COPY package.json package-lock.json* ./
+RUN npm ci --ignore-scripts
+
+# Copy source code
+COPY . .
+
+# Build web UI and check types
+RUN npx vite build --config vite.config.ts
+
+# Production stage
+FROM node:22-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY package.json package-lock.json* ./
+RUN npm ci --ignore-scripts --omit=dev 2>/dev/null || npm ci --ignore-scripts
+
+# Copy built web assets and source (for tsx runtime)
+COPY --from=builder /app/dist/web ./dist/web
+COPY core/ ./core/
+COPY server/ ./server/
+
+# HuggingFace Spaces expects port 7860
+ENV PORT=7860
+ENV STATIC_DIR=/app/dist/web
+EXPOSE 7860
+
+# Run the API server using tsx for TypeScript execution
+RUN npm install -g tsx
+CMD ["tsx", "server/api.ts"]

README.md

@@ -1,10 +1,171 @@
 ---
-title: Ltmarx
-emoji: 📚
-colorFrom: green
-colorTo: blue
+title: LTMarX
+emoji: 🎬
+colorFrom: blue
+colorTo: purple
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LTMarX — Video Watermarking
+
+Imperceptible 32-bit watermarking for video. Embeds a payload into the luminance channel using DWT/DCT transform-domain quantization (DM-QIM) with BCH error correction. Survives re-encoding, rescaling, brightness/contrast/saturation changes.
+
+All processing runs in the browser — no server round-trips needed.
+
+## Quick Start
+
+```bash
+npm install
+npm run dev      # Web UI at localhost:5173
+npm test         # Run test suite
+```
+
+## CLI
+
+```bash
+npx tsx server/cli.ts embed -i input.mp4 -o output.mp4 --key SECRET --preset moderate --payload DEADBEEF
+npx tsx server/cli.ts detect -i output.mp4 --key SECRET
+npx tsx server/cli.ts presets
+```
+
+## Docker
+
+```bash
+docker build -t ltmarx .
+docker run -p 7860:7860 ltmarx
+```
+
+## Architecture
+
+```
+core/           Pure TypeScript watermark engine (isomorphic, zero platform deps)
+├── dwt.ts          Haar DWT (forward/inverse, multi-level)
+├── dct.ts          8×8 DCT with zigzag scan
+├── dmqim.ts        Dither-Modulated QIM (embed/extract with soft decisions)
+├── bch.ts          BCH codec (GF(2^m), Berlekamp-Massey decoding)
+├── crc.ts          CRC-4 / CRC-8 / CRC-16
+├── tiling.ts       Periodic tile layout for redundant embedding
+├── masking.ts      Perceptual masking (variance-adaptive delta)
+├── keygen.ts       Seeded PRNG for dithers and permutations
+├── embedder.ts     Y-plane → watermarked Y-plane
+├── detector.ts     Y-plane → payload + confidence
+├── presets.ts      Named configurations (light → fortress)
+└── types.ts        Shared types
+
+web/            Frontend (Vite + React + Tailwind)
+├── src/
+│   ├── App.tsx
+│   ├── components/
+│   │   ├── EmbedPanel.tsx          Upload, configure, embed
+│   │   ├── DetectPanel.tsx         Upload, detect, display results
+│   │   ├── ApiDocs.tsx             Inline API reference
+│   │   ├── ComparisonView.tsx      Side-by-side / difference viewer
+│   │   ├── RobustnessTest.tsx      Automated attack testing
+│   │   ├── StrengthSlider.tsx      Preset selector with snap points
+│   │   └── ResultCard.tsx          Detection result display
+│   ├── lib/
+│   │   └── video-io.ts            Frame extraction, encoding, attack utilities
+│   └── workers/
+│       └── watermark.worker.ts
+└── index.html
+
+server/         Node.js CLI + HTTP API
+├── cli.ts          CLI for embed/detect
+├── api.ts          HTTP server (serves web UI + REST endpoints)
+└── ffmpeg-io.ts    FFmpeg subprocess for YUV420p I/O
+
+tests/          Vitest test suite
+```
+
+**Design principle:** `core/` has zero platform dependencies — it operates on raw `Uint8Array` Y-plane buffers. The same code runs in the browser (via Canvas + ffmpeg.wasm) and on the server (via Node.js + FFmpeg).
+
+## Watermarking Pipeline
+
+### Embedding
+
+```
+Y plane → 2-level Haar DWT → HL subband → tile grid →
+  per tile: 8×8 DCT blocks → select mid-freq coefficients →
+  DM-QIM embed coded bits → inverse DCT → inverse DWT → modified Y plane
+```
+
+### Payload Encoding
+
+```
+32-bit payload → CRC append → BCH encode → keyed interleave → map to coefficients
+```
+
+### Detection
+
+```
+Y plane → DWT → HL subband → tile grid →
+  per tile: DCT → DM-QIM soft extract →
+  soft-combine across tiles and frames → BCH decode → CRC verify → payload
+```
+
+## Presets
+
+| Preset | Delta | Tile Period | BCH Code | Masking | Use Case |
+|--------|-------|-------------|----------|---------|----------|
+| **Light** | 50 | 256px | (63,36,5) | No | Near-invisible, mild compression |
+| **Moderate** | 80 | 232px | (63,36,5) | Yes | Balanced with perceptual masking |
+| **Strong** | 110 | 208px | (63,36,5) | Yes | More frequencies, handles rescaling |
+| **Fortress** | 150 | 192px | (63,36,5) | Yes | Maximum robustness |
+
+## API
+
+### Embedding
+
+```typescript
+import { embedWatermark } from './core/embedder';
+import { getPreset } from './core/presets';
+
+const config = getPreset('moderate');
+const result = embedWatermark(yPlane, width, height, payload, key, config);
+// result.yPlane: watermarked Y plane
+// result.psnr: quality metric (dB)
+```
+
+### Detection
+
+```typescript
+import { detectWatermarkMultiFrame } from './core/detector';
+import { getPreset } from './core/presets';
+
+const result = detectWatermarkMultiFrame(yPlanes, width, height, key, config);
+// result.detected: boolean
+// result.payload: Uint8Array | null
+// result.confidence: 0–1
+```
+
+### Auto-Detection (tries all presets)
+
+```typescript
+import { autoDetectMultiFrame } from './core/detector';
+
+const result = autoDetectMultiFrame(yPlanes, width, height, key);
+// result.presetUsed: which preset matched
+```
+
+## HTTP API
+
+```
+POST /api/embed   { videoBase64, key, preset, payload }
+POST /api/detect  { videoBase64, key, preset?, frames? }
+GET  /api/health  → { status: "ok" }
+```
+
+## Testing
+
+```bash
+npm test              # Run all tests
+npm run test:watch    # Watch mode
+```
+
+Tests cover: DWT round-trip, DCT round-trip, DM-QIM embed/extract, BCH encode/decode with error correction, CRC append/verify, full embed→detect pipeline across presets, false positive rejection, wrong key rejection.
+
+## Browser Encoding
+
+The web UI encodes watermarked video using ffmpeg.wasm (x264 in WebAssembly). To avoid memory pressure, frames are encoded in chunks of 100 and concatenated at the end. Peak memory stays at ~chunk size rather than scaling with video length.

core/bch.ts

@@ -0,0 +1,395 @@
+/**
+ * BCH (Bose-Chaudhuri-Hocquenghem) Error-Correcting Code
+ *
+ * Supports configurable BCH(n, k, t) codes over GF(2^m).
+ * Uses Berlekamp-Massey decoding with Chien search.
+ */
+
+import type { BchParams } from './types.js';
+
+// Primitive polynomials for GF(2^m)
+const PRIMITIVE_POLYS: Record<number, number> = {
+  6: 0x43,  // x^6 + x + 1
+  7: 0x89,  // x^7 + x^3 + 1
+  8: 0x11D, // x^8 + x^4 + x^3 + x^2 + 1
+};
+
+/**
+ * Galois Field GF(2^m) arithmetic
+ */
+export class GaloisField {
+  readonly m: number;
+  readonly size: number; // 2^m
+  readonly expTable: Int32Array; // alpha^i → element
+  readonly logTable: Int32Array; // element → i (log_alpha)
+
+  constructor(m: number) {
+    this.m = m;
+    this.size = 1 << m;
+    const poly = PRIMITIVE_POLYS[m];
+    if (!poly) throw new Error(`No primitive polynomial for GF(2^${m})`);
+
+    this.expTable = new Int32Array(this.size * 2);
+    this.logTable = new Int32Array(this.size);
+    this.logTable[0] = -1; // log(0) undefined
+
+    let val = 1;
+    for (let i = 0; i < this.size - 1; i++) {
+      this.expTable[i] = val;
+      this.logTable[val] = i;
+      val <<= 1;
+      if (val >= this.size) {
+        val ^= poly;
+        val &= this.size - 1;
+      }
+    }
+    // Extend exp table for easier modular arithmetic
+    for (let i = this.size - 1; i < this.size * 2; i++) {
+      this.expTable[i] = this.expTable[i - (this.size - 1)];
+    }
+  }
+
+  mul(a: number, b: number): number {
+    if (a === 0 || b === 0) return 0;
+    return this.expTable[this.logTable[a] + this.logTable[b]];
+  }
+
+  div(a: number, b: number): number {
+    if (b === 0) throw new Error('Division by zero in GF');
+    if (a === 0) return 0;
+    let exp = this.logTable[a] - this.logTable[b];
+    if (exp < 0) exp += this.size - 1;
+    return this.expTable[exp];
+  }
+
+  pow(a: number, e: number): number {
+    if (a === 0) return e === 0 ? 1 : 0;
+    let log = (this.logTable[a] * e) % (this.size - 1);
+    if (log < 0) log += this.size - 1;
+    return this.expTable[log];
+  }
+
+  inv(a: number): number {
+    if (a === 0) throw new Error('Inverse of zero');
+    return this.expTable[this.size - 1 - this.logTable[a]];
+  }
+}
+
+/**
+ * Compute the generator polynomial for a binary BCH code.
+ * The generator is the LCM of minimal polynomials of alpha^1 through alpha^(2t).
+ * All minimal polynomials over GF(2) have binary (0/1) coefficients.
+ */
+function computeGeneratorPoly(gf: GaloisField, t: number): Uint8Array {
+  // Start with g(x) = 1 as a binary polynomial
+  let gen = new Uint8Array([1]);
+  const order = gf.size - 1;
+  const processed = new Set<number>();
+
+  for (let i = 1; i <= 2 * t; i++) {
+    // Normalize i modulo the field order
+    const norm = i % order;
+    if (processed.has(norm)) continue;
+
+    // Find conjugate class of alpha^i: {i, 2i, 4i, ...} mod order
+    const conjugates: number[] = [];
+    let r = norm;
+    for (let j = 0; j < gf.m; j++) {
+      const rNorm = r % order;
+      if (conjugates.includes(rNorm)) break;
+      conjugates.push(rNorm);
+      processed.add(rNorm);
+      r = (r * 2) % order;
+    }
+
+    // Compute minimal polynomial: product of (x + alpha^c) for c in conjugate class
+    // Start with [1] (= 1), then multiply by each (x + alpha^c)
+    // Coefficients are in GF(2^m), but we reduce to binary at the end
+    let minPoly = [1]; // GF(2^m) coefficients
+    for (const c of conjugates) {
+      const root = gf.expTable[c];
+      const newPoly = new Array(minPoly.length + 1).fill(0);
+      for (let k = 0; k < minPoly.length; k++) {
+        newPoly[k + 1] ^= minPoly[k];           // x * term
+        newPoly[k] ^= gf.mul(minPoly[k], root);  // root * term
+      }
+      minPoly = newPoly;
+    }
+
+    // Convert to binary (all coefficients should be 0 or 1 for minimal polys over GF(2))
+    const binaryMinPoly = new Uint8Array(minPoly.length);
+    for (let j = 0; j < minPoly.length; j++) {
+      binaryMinPoly[j] = minPoly[j] === 0 ? 0 : 1;
+    }
+
+    // Multiply gen by binaryMinPoly (binary polynomial multiplication)
+    const newGen = new Uint8Array(gen.length + binaryMinPoly.length - 1);
+    for (let a = 0; a < gen.length; a++) {
+      if (!gen[a]) continue;
+      for (let b = 0; b < binaryMinPoly.length; b++) {
+        if (binaryMinPoly[b]) {
+          newGen[a + b] ^= 1;
+        }
+      }
+    }
+    gen = newGen;
+  }
+
+  return gen;
+}
+
+/**
+ * BCH Encoder/Decoder
+ */
+export class BchCodec {
+  readonly params: BchParams;
+  readonly gf: GaloisField;
+  private readonly genPoly: Uint8Array;
+  private readonly genPolyDeg: number;
+
+  constructor(params: BchParams) {
+    this.params = params;
+    this.gf = new GaloisField(params.m);
+    this.genPoly = computeGeneratorPoly(this.gf, params.t);
+    this.genPolyDeg = this.genPoly.length - 1;
+  }
+
+  /**
+   * Encode message bits (length k) into codeword bits (length n)
+   * Systematic encoding: message bits appear at the start
+   */
+  encode(message: Uint8Array): Uint8Array {
+    const { n, k } = this.params;
+    if (message.length !== k) {
+      throw new Error(`Message length ${message.length} !== k=${k}`);
+    }
+
+    const nk = n - k;
+    const codeword = new Uint8Array(n);
+    codeword.set(message);
+
+    // Compute remainder: m(x) * x^(n-k) mod g(x) using binary polynomial long division
+    const dividend = new Uint8Array(n);
+    // Place message coefficients at positions nk..n-1 (high degree)
+    // In our polynomial representation, index i = coefficient of x^i
+    // For systematic encoding: codeword(x) = m(x) * x^(n-k) + remainder
+    for (let i = 0; i < k; i++) {
+      dividend[nk + i] = message[i];
+    }
+
+    // Long division
+    const rem = new Uint8Array(dividend);
+    for (let i = n - 1; i >= nk; i--) {
+      if (rem[i]) {
+        for (let j = 0; j <= this.genPolyDeg; j++) {
+          rem[i - this.genPolyDeg + j] ^= this.genPoly[j];
+        }
+      }
+    }
+
+    // Codeword = message (high positions) + remainder (low positions)
+    for (let i = 0; i < nk; i++) {
+      codeword[k + i] = message[i]; // Will be overwritten below
+    }
+
+    // Actually: codeword[i] for i=0..nk-1 is remainder, for i=nk..n-1 is message
+    // Let's use standard ordering: codeword = [message | parity]
+    // where c(x) = m(x) * x^(n-k) + (m(x) * x^(n-k) mod g(x))
+    for (let i = 0; i < k; i++) {
+      codeword[i] = message[i];
+    }
+    for (let i = 0; i < nk; i++) {
+      codeword[k + i] = rem[i];
+    }
+
+    return codeword;
+  }
+
+  /**
+   * Decode a received codeword. Returns corrected message bits or null if uncorrectable.
+   */
+  decode(received: Uint8Array): Uint8Array | null {
+    const { n, k, t } = this.params;
+    if (received.length !== n) {
+      throw new Error(`Received length ${received.length} !== n=${n}`);
+    }
+
+    // Convert to polynomial form matching our encoding
+    // received[0..k-1] = message bits, received[k..n-1] = parity bits
+    // As polynomial: r(x) = sum r[i] * x^(n-k+i) for i=0..k-1, + sum r[k+i] * x^i for i=0..n-k-1
+    const nk = n - k;
+    const rPoly = new Uint8Array(n);
+    for (let i = 0; i < k; i++) {
+      rPoly[nk + i] = received[i];
+    }
+    for (let i = 0; i < nk; i++) {
+      rPoly[i] = received[k + i];
+    }
+
+    // Compute syndromes S_1 ... S_{2t}
+    // S_j = r(alpha^j) for j = 1..2t
+    const syndromes = new Array<number>(2 * t);
+    let hasErrors = false;
+
+    for (let j = 0; j < 2 * t; j++) {
+      let s = 0;
+      let alphaPow = 1; // alpha^((j+1)*0)
+      const alphaJ = this.gf.expTable[j + 1]; // alpha^(j+1)
+      for (let i = 0; i < n; i++) {
+        if (rPoly[i]) {
+          s ^= alphaPow;
+        }
+        alphaPow = this.gf.mul(alphaPow, alphaJ);
+      }
+      syndromes[j] = s;
+      if (s !== 0) hasErrors = true;
+    }
+
+    if (!hasErrors) {
+      return new Uint8Array(received.subarray(0, k));
+    }
+
+    // Berlekamp-Massey to find error locator polynomial
+    const sigma = this.berlekampMassey(syndromes, t);
+    if (!sigma) return null;
+
+    // Chien search to find error positions in polynomial representation
+    const errorPolyPositions = this.chienSearch(sigma, n);
+    if (!errorPolyPositions || errorPolyPositions.length !== sigma.length - 1) {
+      return null;
+    }
+
+    // Correct errors in polynomial representation
+    const correctedPoly = new Uint8Array(rPoly);
+    for (const pos of errorPolyPositions) {
+      if (pos >= n) return null;
+      correctedPoly[pos] ^= 1;
+    }
+
+    // Verify: recompute syndromes should all be zero
+    for (let j = 0; j < 2 * t; j++) {
+      let s = 0;
+      let alphaPow = 1;
+      const alphaJ = this.gf.expTable[j + 1];
+      for (let i = 0; i < n; i++) {
+        if (correctedPoly[i]) s ^= alphaPow;
+        alphaPow = this.gf.mul(alphaPow, alphaJ);
+      }
+      if (s !== 0) return null;
+    }
+
+    // Extract message bits from corrected polynomial
+    const message = new Uint8Array(k);
+    for (let i = 0; i < k; i++) {
+      message[i] = correctedPoly[nk + i];
+    }
+    return message;
+  }
+
+  /**
+   * Berlekamp-Massey algorithm
+   */
+  private berlekampMassey(syndromes: number[], t: number): number[] | null {
+    const gf = this.gf;
+    const twoT = 2 * t;
+
+    let C = [1];
+    let B = [1];
+    let L = 0;
+    let m = 1;
+    let b = 1;
+
+    for (let n = 0; n < twoT; n++) {
+      let d = syndromes[n];
+      for (let i = 1; i <= L; i++) {
+        if (i < C.length && (n - i) >= 0) {
+          d ^= gf.mul(C[i], syndromes[n - i]);
+        }
+      }
+
+      if (d === 0) {
+        m++;
+      } else if (2 * L <= n) {
+        const T = [...C];
+        const factor = gf.div(d, b);
+        while (C.length < B.length + m) C.push(0);
+        for (let i = 0; i < B.length; i++) {
+          C[i + m] ^= gf.mul(factor, B[i]);
+        }
+        L = n + 1 - L;
+        B = T;
+        b = d;
+        m = 1;
+      } else {
+        const factor = gf.div(d, b);
+        while (C.length < B.length + m) C.push(0);
+        for (let i = 0; i < B.length; i++) {
+          C[i + m] ^= gf.mul(factor, B[i]);
+        }
+        m++;
+      }
+    }
+
+    if (L > t) return null;
+    return C;
+  }
+
+  /**
+   * Chien search: find roots of the error locator polynomial.
+   *
+   * sigma(x) = prod(1 - alpha^(e_j) * x), so roots are at x = alpha^(-e_j).
+   * We test x = alpha^(-i) for i = 0..n-1. If sigma(alpha^(-i)) = 0,
+   * then error position is i (in polynomial index).
+   */
+  private chienSearch(sigma: number[], n: number): number[] | null {
+    const gf = this.gf;
+    const positions: number[] = [];
+    const degree = sigma.length - 1;
+    const order = gf.size - 1;
+
+    for (let i = 0; i < n; i++) {
+      // Evaluate sigma at alpha^(-i)
+      let val = sigma[0]; // = 1
+      for (let j = 1; j < sigma.length; j++) {
+        // alpha^(-i*j) = alpha^(order - i*j mod order)
+        let exp = (order - ((i * j) % order)) % order;
+        val ^= gf.mul(sigma[j], gf.expTable[exp]);
+      }
+      if (val === 0) {
+        positions.push(i);
+      }
+    }
+
+    if (positions.length !== degree) return null;
+    return positions;
+  }
+
+  /**
+   * Soft-decode: use soft input values to attempt decoding
+   */
+  decodeSoft(softBits: Float64Array): { message: Uint8Array | null; reliable: boolean } {
+    const hard = new Uint8Array(softBits.length);
+    for (let i = 0; i < softBits.length; i++) {
+      hard[i] = softBits[i] > 0 ? 1 : 0;
+    }
+
+    const decoded = this.decode(hard);
+    if (decoded) {
+      let reliabilitySum = 0;
+      for (let i = 0; i < softBits.length; i++) {
+        reliabilitySum += Math.abs(softBits[i]);
+      }
+      const avgReliability = reliabilitySum / softBits.length;
+      return { message: decoded, reliable: avgReliability > 0.15 };
+    }
+
+    return { message: null, reliable: false };
+  }
+}
+
+/**
+ * Create BCH codec from standard parameters
+ */
+export function createBchCodec(params: BchParams): BchCodec {
+  return new BchCodec(params);
+}

core/crc.ts

@@ -0,0 +1,72 @@
+/**
+ * CRC computation for payload integrity verification
+ * Supports CRC-4, CRC-8, and CRC-16
+ */
+
+// CRC-4 polynomial: x^4 + x + 1 (0x13, used bits: 0x03)
+const CRC4_POLY = 0x03;
+// CRC-8 polynomial: x^8 + x^2 + x + 1 (CRC-8-CCITT)
+const CRC8_POLY = 0x07;
+// CRC-16 polynomial: x^16 + x^15 + x^2 + 1 (CRC-16-IBM)
+const CRC16_POLY = 0x8005;
+
+/**
+ * Compute CRC over a bit array
+ * Uses non-zero initial value to prevent all-zeros from having CRC=0
+ */
+function computeCrc(bits: Uint8Array, poly: number, crcBits: number): number {
+  const mask = (1 << crcBits) - 1;
+  let crc = mask; // Non-zero init: all 1s (0xF for CRC-4, 0xFF for CRC-8, 0xFFFF for CRC-16)
+
+  for (let i = 0; i < bits.length; i++) {
+    crc ^= (bits[i] & 1) << (crcBits - 1);
+    if (crc & (1 << (crcBits - 1))) {
+      crc = ((crc << 1) ^ poly) & mask;
+    } else {
+      crc = (crc << 1) & mask;
+    }
+  }
+
+  return crc;
+}
+
+/**
+ * Compute CRC and append to bit array
+ */
+export function crcAppend(bits: Uint8Array, crcBits: 4 | 8 | 16): Uint8Array {
+  const poly = crcBits === 4 ? CRC4_POLY : crcBits === 8 ? CRC8_POLY : CRC16_POLY;
+  const crc = computeCrc(bits, poly, crcBits);
+
+  const result = new Uint8Array(bits.length + crcBits);
+  result.set(bits);
+
+  // Append CRC bits (MSB first)
+  for (let i = 0; i < crcBits; i++) {
+    result[bits.length + i] = (crc >> (crcBits - 1 - i)) & 1;
+  }
+
+  return result;
+}
+
+/**
+ * Verify CRC on a bit array (last crcBits bits are the CRC)
+ * Returns the payload bits (without CRC) if valid, null otherwise
+ */
+export function crcVerify(bits: Uint8Array, crcBits: 4 | 8 | 16): Uint8Array | null {
+  if (bits.length <= crcBits) return null;
+
+  const payload = bits.subarray(0, bits.length - crcBits);
+  const poly = crcBits === 4 ? CRC4_POLY : crcBits === 8 ? CRC8_POLY : CRC16_POLY;
+  const computed = computeCrc(payload, poly, crcBits);
+
+  // Extract received CRC
+  let received = 0;
+  for (let i = 0; i < crcBits; i++) {
+    received |= (bits[bits.length - crcBits + i] & 1) << (crcBits - 1 - i);
+  }
+
+  if (computed === received) {
+    return new Uint8Array(payload);
+  }
+  return null;
+}

core/dct.ts

@@ -0,0 +1,156 @@
+/**
+ * 8x8 DCT forward and inverse transforms
+ * Separable implementation: rows then columns — O(N^3) instead of O(N^4)
+ * Reuses temp buffers to avoid per-call allocations
+ */
+
+const N = 8;
+
+// Precompute cosine table: cos((2i+1)*j*PI / 16) for i,j in [0,8)
+const COS_TABLE = new Float64Array(N * N);
+for (let i = 0; i < N; i++) {
+  for (let j = 0; j < N; j++) {
+    COS_TABLE[i * N + j] = Math.cos(((2 * i + 1) * j * Math.PI) / (2 * N));
+  }
+}
+
+// Precompute alpha normalization table: alpha(u) * alpha(v) for all (u,v)
+const ALPHA_0 = 1 / Math.sqrt(N);
+const ALPHA_K = Math.sqrt(2 / N);
+const ALPHA_UV = new Float64Array(N * N);
+const ALPHA = new Float64Array(N);
+for (let k = 0; k < N; k++) ALPHA[k] = k === 0 ? ALPHA_0 : ALPHA_K;
+for (let u = 0; u < N; u++) {
+  for (let v = 0; v < N; v++) {
+    ALPHA_UV[u * N + v] = ALPHA[u] * ALPHA[v];
+  }
+}
+
+// Precompute scaled cosine: ALPHA[k] * COS_TABLE[i*N+k] for forward transform
+const SCALED_COS = new Float64Array(N * N);
+for (let i = 0; i < N; i++) {
+  for (let k = 0; k < N; k++) {
+    SCALED_COS[i * N + k] = ALPHA[k] * COS_TABLE[i * N + k];
+  }
+}
+
+// Shared temp buffers (avoids allocation per call)
+const _temp64 = new Float64Array(64);
+const _temp8 = new Float64Array(8);
+
+/**
+ * Forward 8x8 DCT on a block (in-place)
+ * Separable: transform rows, then columns — O(8^3) = 512 ops vs O(8^4) = 4096
+ */
+export function dctForward8x8(block: Float64Array): void {
+  // Step 1: Transform each row (spatial x → frequency v)
+  for (let x = 0; x < N; x++) {
+    const rowOff = x * N;
+    for (let v = 0; v < N; v++) {
+      let sum = 0;
+      for (let y = 0; y < N; y++) {
+        sum += block[rowOff + y] * COS_TABLE[y * N + v];
+      }
+      _temp64[rowOff + v] = ALPHA[v] * sum;
+    }
+  }
+
+  // Step 2: Transform each column (spatial x → frequency u)
+  for (let v = 0; v < N; v++) {
+    for (let u = 0; u < N; u++) {
+      let sum = 0;
+      for (let x = 0; x < N; x++) {
+        sum += _temp64[x * N + v] * COS_TABLE[x * N + u];
+      }
+      block[u * N + v] = ALPHA[u] * sum;
+    }
+  }
+}
+
+/**
+ * Inverse 8x8 DCT on a block (in-place)
+ * Separable: inverse columns, then inverse rows
+ */
+export function dctInverse8x8(block: Float64Array): void {
+  // Step 1: Inverse transform columns (frequency u → spatial x)
+  for (let v = 0; v < N; v++) {
+    for (let x = 0; x < N; x++) {
+      let sum = 0;
+      for (let u = 0; u < N; u++) {
+        sum += ALPHA[u] * block[u * N + v] * COS_TABLE[x * N + u];
+      }
+      _temp64[x * N + v] = sum;
+    }
+  }
+
+  // Step 2: Inverse transform rows (frequency v → spatial y)
+  for (let x = 0; x < N; x++) {
+    const rowOff = x * N;
+    for (let y = 0; y < N; y++) {
+      let sum = 0;
+      for (let v = 0; v < N; v++) {
+        sum += ALPHA[v] * _temp64[rowOff + v] * COS_TABLE[y * N + v];
+      }
+      block[rowOff + y] = sum;
+    }
+  }
+}
+
+/**
+ * Zigzag scan order for 8x8 block
+ * Maps zigzag index → [row, col]
+ */
+export const ZIGZAG_ORDER: [number, number][] = [
+  [0,0],[0,1],[1,0],[2,0],[1,1],[0,2],[0,3],[1,2],
+  [2,1],[3,0],[4,0],[3,1],[2,2],[1,3],[0,4],[0,5],
+  [1,4],[2,3],[3,2],[4,1],[5,0],[6,0],[5,1],[4,2],
+  [3,3],[2,4],[1,5],[0,6],[0,7],[1,6],[2,5],[3,4],
+  [4,3],[5,2],[6,1],[7,0],[7,1],[6,2],[5,3],[4,4],
+  [3,5],[2,6],[1,7],[2,7],[3,6],[4,5],[5,4],[6,3],
+  [7,2],[7,3],[6,4],[5,5],[4,6],[3,7],[4,7],[5,6],
+  [6,5],[7,4],[7,5],[6,6],[5,7],[6,7],[7,6],[7,7],
+];
+
+/**
+ * Extract an 8x8 block from a subband into a reusable buffer
+ */
+export function extractBlock(
+  data: Float64Array,
+  width: number,
+  blockRow: number,
+  blockCol: number,
+  out?: Float64Array
+): Float64Array {
+  const block = out || new Float64Array(64);
+  const startY = blockRow * 8;
+  const startX = blockCol * 8;
+  for (let r = 0; r < 8; r++) {
+    const srcOff = (startY + r) * width + startX;
+    const dstOff = r * 8;
+    for (let c = 0; c < 8; c++) {
+      block[dstOff + c] = data[srcOff + c];
+    }
+  }
+  return block;
+}
+
+/**
+ * Write an 8x8 block back into a subband
+ */
+export function writeBlock(
+  data: Float64Array,
+  width: number,
+  blockRow: number,
+  blockCol: number,
+  block: Float64Array
+): void {
+  const startY = blockRow * 8;
+  const startX = blockCol * 8;
+  for (let r = 0; r < 8; r++) {
+    const dstOff = (startY + r) * width + startX;
+    const srcOff = r * 8;
+    for (let c = 0; c < 8; c++) {
+      data[dstOff + c] = block[srcOff + c];
+    }
+  }
+}

core/detector.ts

@@ -0,0 +1,340 @@
+/**
+ * High-level watermark detector
+ *
+ * Takes a Y plane + key + config → returns detection result
+ */
+
+import type { WatermarkConfig, DetectionResult, Buffer2D } from './types.js';
+import { yPlaneToBuffer, dwtForward, extractSubband } from './dwt.js';
+import { dctForward8x8, extractBlock, ZIGZAG_ORDER } from './dct.js';
+import { dmqimExtractSoft } from './dmqim.js';
+import { crcVerify } from './crc.js';
+import { BchCodec } from './bch.js';
+import { generateDithers, generatePermutation } from './keygen.js';
+import { computeTileGrid, getTileOrigin, getTileBlocks, type TileGrid } from './tiling.js';
+import { blockAcEnergy, computeMaskingFactors } from './masking.js';
+import { bitsToPayload } from './embedder.js';
+import { PRESETS } from './presets.js';
+import type { PresetName } from './types.js';
+
+/**
+ * Detect and extract watermark from a single Y plane
+ */
+export function detectWatermark(
+  yPlane: Uint8Array,
+  width: number,
+  height: number,
+  key: string,
+  config: WatermarkConfig
+): DetectionResult {
+  return detectWatermarkMultiFrame([yPlane], width, height, key, config);
+}
+
+/**
+ * Extract per-tile soft decisions from a single Y plane.
+ * Returns an array of soft-bit vectors, one per tile.
+ */
+/** Precomputed DWT subband + tile grid info for a frame */
+interface FrameDWT {
+  hlSubband: Buffer2D;
+  subbandTilePeriod: number;
+}
+
+function computeFrameDWT(
+  yPlane: Uint8Array,
+  width: number,
+  height: number,
+  config: WatermarkConfig
+): FrameDWT {
+  const buf = yPlaneToBuffer(yPlane, width, height);
+  const { buf: dwtBuf, dims } = dwtForward(buf, config.dwtLevels);
+  const hlSubband = extractSubband(dwtBuf, dims[dims.length - 1].w, dims[dims.length - 1].h, 'HL');
+  const subbandTilePeriod = Math.floor(config.tilePeriod / (1 << config.dwtLevels));
+  return { hlSubband, subbandTilePeriod };
+}
+
+function extractSoftBitsFromSubband(
+  hlSubband: Buffer2D,
+  tileGrid: TileGrid,
+  key: string,
+  config: WatermarkConfig
+): { tileSoftBits: Float64Array[]; totalTiles: number } | null {
+  if (tileGrid.totalTiles === 0) return null;
+
+  const codedLength = config.bch.n;
+  const maxCoeffsPerTile = 1024;
+  const dithers = generateDithers(key, maxCoeffsPerTile, config.delta);
+
+  const tileSoftBits: Float64Array[] = [];
+  const blockBuf = new Float64Array(64);
+
+  // Precompute zigzag → coefficient index mapping
+  const zigCoeffIdx = new Int32Array(config.zigzagPositions.length);
+  for (let z = 0; z < config.zigzagPositions.length; z++) {
+    const [r, c] = ZIGZAG_ORDER[config.zigzagPositions[z]];
+    zigCoeffIdx[z] = r * 8 + c;
+  }
+
+  for (let tileIdx = 0; tileIdx < tileGrid.totalTiles; tileIdx++) {
+    let ditherIdx = 0; // Reset per tile — matches embedder
+    const origin = getTileOrigin(tileGrid, tileIdx);
+    const blocks = getTileBlocks(origin.x, origin.y, tileGrid.tilePeriod, hlSubband.width, hlSubband.height);
+
+    const softBits = new Float64Array(codedLength);
+    const bitCounts = new Float64Array(codedLength);
+
+    let maskingFactors: Float64Array | null = null;
+    if (config.perceptualMasking && blocks.length > 0) {
+      const energies = new Float64Array(blocks.length);
+      for (let bi = 0; bi < blocks.length; bi++) {
+        extractBlock(hlSubband.data, hlSubband.width, blocks[bi].row, blocks[bi].col, blockBuf);
+        dctForward8x8(blockBuf);
+        energies[bi] = blockAcEnergy(blockBuf);
+      }
+      maskingFactors = computeMaskingFactors(energies);
+    }
+
+    let bitIdx = 0;
+    for (let bi = 0; bi < blocks.length; bi++) {
+      const { row, col } = blocks[bi];
+      extractBlock(hlSubband.data, hlSubband.width, row, col, blockBuf);
+      dctForward8x8(blockBuf);
+
+      const maskFactor = maskingFactors ? maskingFactors[bi] : 1.0;
+      const effectiveDelta = config.delta * maskFactor;
+
+      for (let z = 0; z < zigCoeffIdx.length; z++) {
+        if (bitIdx >= codedLength) bitIdx = 0;
+
+        const coeffIdx = zigCoeffIdx[z];
+        const dither = dithers[ditherIdx++];
+
+        const soft = dmqimExtractSoft(blockBuf[coeffIdx], effectiveDelta, dither);
+        softBits[bitIdx] += soft;
+        bitCounts[bitIdx]++;
+
+        bitIdx++;
+      }
+    }
+
+    for (let i = 0; i < codedLength; i++) {
+      if (bitCounts[i] > 0) softBits[i] /= bitCounts[i];
+    }
+
+    tileSoftBits.push(softBits);
+  }
+
+  return { tileSoftBits, totalTiles: tileGrid.totalTiles };
+}
+
+/**
+ * Detect watermark from multiple Y planes.
+ * Extracts soft decisions from each frame independently, then combines
+ * across frames and tiles (never averages raw pixels).
+ */
+export function detectWatermarkMultiFrame(
+  yPlanes: Uint8Array[],
+  width: number,
+  height: number,
+  key: string,
+  config: WatermarkConfig,
+): DetectionResult {
+  const noResult: DetectionResult = {
+    detected: false,
+    payload: null,
+    confidence: 0,
+    tilesDecoded: 0,
+    tilesTotal: 0,
+  };
+
+  if (yPlanes.length === 0) return noResult;
+
+  const codedLength = config.bch.n;
+  const bch = new BchCodec(config.bch);
+  const perm = generatePermutation(key, codedLength);
+
+  // Helper: try to detect with given frames and explicit tile grid
+  const tryWithGrid = (
+    frames: FrameDWT[],
+    makeGrid: (hlSubband: Buffer2D, stp: number) => TileGrid,
+  ): DetectionResult | null => {
+    const softBits: Float64Array[] = [];
+    for (const { hlSubband, subbandTilePeriod } of frames) {
+      const tileGrid = makeGrid(hlSubband, subbandTilePeriod);
+      const frameResult = extractSoftBitsFromSubband(hlSubband, tileGrid, key, config);
+      if (frameResult) softBits.push(...frameResult.tileSoftBits);
+    }
+    if (softBits.length === 0) return null;
+    return decodeFromSoftBits(softBits, codedLength, perm, bch, config);
+  };
+
+  // Fast path: zero-phase grid (uncropped frames)
+  const frameDWTs = yPlanes.map((yp) => computeFrameDWT(yp, width, height, config));
+  const fast = tryWithGrid(frameDWTs, (hl, stp) =>
+    computeTileGrid(hl.width, hl.height, stp));
+  if (fast) return fast;
+
+  return noResult;
+}
+
+/**
+ * Combine soft bits from all tiles, decode, and compute confidence.
+ * Returns null if decoding fails or confidence is too low.
+ */
+function decodeFromSoftBits(
+  allTileSoftBits: Float64Array[],
+  codedLength: number,
+  perm: Uint32Array,
+  bch: BchCodec,
+  config: WatermarkConfig
+): DetectionResult | null {
+  const combined = new Float64Array(codedLength);
+  for (const tileSoft of allTileSoftBits) {
+    for (let i = 0; i < codedLength; i++) {
+      combined[i] += tileSoft[i];
+    }
+  }
+  for (let i = 0; i < codedLength; i++) {
+    combined[i] /= allTileSoftBits.length;
+  }
+
+  const decoded = tryDecode(combined, perm, bch, config);
+  if (!decoded) return null;
+
+  // Cross-validate — count how many individual tiles agree with the combined decode
+  const reEncoded = bch.encode(decoded.rawMessage);
+  let agreeTiles = 0;
+
+  for (const tileSoft of allTileSoftBits) {
+    const deinterleaved = new Float64Array(codedLength);
+    for (let i = 0; i < codedLength; i++) {
+      deinterleaved[i] = tileSoft[perm[i]];
+    }
+    let matching = 0;
+    for (let i = 0; i < codedLength; i++) {
+      const hardBit = deinterleaved[i] > 0 ? 1 : 0;
+      if (hardBit === reEncoded[i]) matching++;
+    }
+    if (matching / codedLength > 0.65) agreeTiles++;
+  }
+
+  const totalTileCount = allTileSoftBits.length;
+  const zSingle = 0.3 * Math.sqrt(codedLength);
+  const pChance = Math.max(1e-10, 0.5 * Math.exp(-0.5 * zSingle * zSingle));
+
+  const expected = totalTileCount * pChance;
+  const stddev = Math.sqrt(totalTileCount * pChance * (1 - pChance));
+  const z = stddev > 0 ? (agreeTiles - expected) / stddev : agreeTiles > expected ? 100 : 0;
+  const statsConfidence = Math.max(0, Math.min(1.0, 1 - Math.exp(-z * 0.5)));
+
+  const confidence = Math.max(statsConfidence, decoded.softConfidence);
+
+  if (confidence < MIN_CONFIDENCE) return null;
+
+  return {
+    detected: true,
+    payload: decoded.payload,
+    confidence,
+    tilesDecoded: agreeTiles,
+    tilesTotal: allTileSoftBits.length,
+  };
+}
+
+/** Minimum confidence to report a detection (low threshold is fine —
+ *  the statistical model already ensures noise scores near 0%) */
+const MIN_CONFIDENCE = 0.10;
+
+/**
+ * Try to decode soft bits into a payload
+ */
+function tryDecode(
+  softBits: Float64Array,
+  perm: Uint32Array,
+  bch: BchCodec,
+  config: WatermarkConfig
+): { payload: Uint8Array; rawMessage: Uint8Array; softConfidence: number } | null {
+  const codedLength = config.bch.n;
+
+  // De-interleave
+  const deinterleaved = new Float64Array(codedLength);
+  for (let i = 0; i < codedLength; i++) {
+    deinterleaved[i] = softBits[perm[i]];
+  }
+
+  // BCH soft decode
+  const { message, reliable } = bch.decodeSoft(deinterleaved);
+  if (!message) return null;
+
+  // Extract the CRC-protected portion (first 32 + crc_bits of the BCH message)
+  const PAYLOAD_BITS = 32;
+  const crcProtectedLen = PAYLOAD_BITS + config.crc.bits;
+  const crcProtected = message.subarray(0, crcProtectedLen);
+
+  // CRC verify the 32-bit payload
+  const verified = crcVerify(crcProtected, config.crc.bits);
+  if (!verified) return null;
+
+  // Convert 32 payload bits to bytes
+  const payload = bitsToPayload(verified);
+
+  // Soft confidence = correlation between soft decisions and decoded codeword.
+  // Real signal: soft values are large AND agree with the codeword → high correlation.
+  // Noise that BCH happened to decode: soft values are small/random → low correlation.
+  const reEncoded = bch.encode(message);
+  let correlation = 0;
+  for (let i = 0; i < codedLength; i++) {
+    const sign = reEncoded[i] === 1 ? 1 : -1;
+    correlation += sign * deinterleaved[i];
+  }
+  correlation /= codedLength;
+  const softConfidence = Math.max(0, Math.min(1.0, correlation * 2));
+
+  return { payload, rawMessage: message, softConfidence };
+}
+
+/** Extended detection result that includes which preset matched */
+export interface AutoDetectResult extends DetectionResult {
+  /** The preset that produced the detection (null if not detected) */
+  presetUsed: PresetName | null;
+}
+
+/**
+ * Auto-detect: try all presets and return the best result.
+ * No need for the user to know which preset was used during embedding.
+ */
+export function autoDetect(
+  yPlane: Uint8Array,
+  width: number,
+  height: number,
+  key: string,
+): AutoDetectResult {
+  return autoDetectMultiFrame([yPlane], width, height, key);
+}
+
+/**
+ * Auto-detect with multiple frames: try all presets, return the best result.
+ */
+export function autoDetectMultiFrame(
+  yPlanes: Uint8Array[],
+  width: number,
+  height: number,
+  key: string,
+): AutoDetectResult {
+  let best: AutoDetectResult = {
+    detected: false,
+    payload: null,
+    confidence: 0,
+    tilesDecoded: 0,
+    tilesTotal: 0,
+    presetUsed: null,
+  };
+
+  for (const [name, config] of Object.entries(PRESETS)) {
+    const result = detectWatermarkMultiFrame(yPlanes, width, height, key, config);
+    if (result.detected && result.confidence > best.confidence) {
+      best = { ...result, presetUsed: name as PresetName };
+    }
+  }
+
+  return best;
+}

core/dmqim.ts

@@ -0,0 +1,69 @@
+/**
+ * Dither-Modulated Quantization Index Modulation (DM-QIM)
+ *
+ * Embeds a single bit into a coefficient using quantization.
+ * The dither value provides key-dependent randomization.
+ */
+
+/**
+ * Embed a single bit into a coefficient using DM-QIM
+ *
+ * @param coeff - Original coefficient value
+ * @param bit - Bit to embed (0 or 1)
+ * @param delta - Quantization step size
+ * @param dither - Key-dependent dither value
+ * @returns Watermarked coefficient
+ */
+export function dmqimEmbed(coeff: number, bit: number, delta: number, dither: number): number {
+  // Dither modulation: shift coefficient by dither before quantizing
+  const shifted = coeff - dither;
+
+  // Quantize to the nearest lattice point for the given bit
+  // Bit 0 → even quantization levels: ..., -2Δ, 0, 2Δ, ...
+  // Bit 1 → odd quantization levels:  ..., -Δ, Δ, 3Δ, ...
+  const halfDelta = delta / 2;
+
+  if (bit === 0) {
+    // Quantize to nearest even multiple of delta
+    const quantized = Math.round(shifted / delta) * delta;
+    return quantized + dither;
+  } else {
+    // Quantize to nearest odd multiple of delta (offset by delta/2)
+    const quantized = Math.round((shifted - halfDelta) / delta) * delta + halfDelta;
+    return quantized + dither;
+  }
+}
+
+/**
+ * Extract a soft decision from a coefficient using DM-QIM
+ *
+ * Returns a signed float:
+ *   Positive → likely bit 1
+ *   Negative → likely bit 0
+ *   Magnitude → confidence (closer to ±delta/4 = maximum confidence)
+ *
+ * @param coeff - Possibly watermarked coefficient
+ * @param delta - Quantization step size
+ * @param dither - Key-dependent dither value (must match embed)
+ * @returns Soft decision value in [-delta/4, +delta/4]
+ */
+export function dmqimExtractSoft(coeff: number, delta: number, dither: number): number {
+  const shifted = coeff - dither;
+  const halfDelta = delta / 2;
+
+  // Distance to nearest even lattice point (bit 0)
+  const d0 = Math.abs(shifted - Math.round(shifted / delta) * delta);
+  // Distance to nearest odd lattice point (bit 1)
+  const d1 = Math.abs(shifted - halfDelta - Math.round((shifted - halfDelta) / delta) * delta);
+
+  // Soft output: positive for bit 1, negative for bit 0
+  // Magnitude reflects confidence
+  return (d0 - d1) / delta;
+}
+
+/**
+ * Extract a hard decision (0 or 1) from a coefficient
+ */
+export function dmqimExtractHard(coeff: number, delta: number, dither: number): number {
+  return dmqimExtractSoft(coeff, delta, dither) > 0 ? 1 : 0;
+}

core/dwt.ts

@@ -0,0 +1,221 @@
+import type { Buffer2D, DwtResult } from './types.js';
+
+/**
+ * Create a 2D buffer
+ */
+export function createBuffer2D(width: number, height: number): Buffer2D {
+  return { data: new Float64Array(width * height), width, height };
+}
+
+/**
+ * Copy a Buffer2D
+ */
+export function copyBuffer2D(buf: Buffer2D): Buffer2D {
+  return { data: new Float64Array(buf.data), width: buf.width, height: buf.height };
+}
+
+/**
+ * Get value from 2D buffer
+ */
+function get(buf: Buffer2D, x: number, y: number): number {
+  return buf.data[y * buf.width + x];
+}
+
+/**
+ * Set value in 2D buffer
+ */
+function set(buf: Buffer2D, x: number, y: number, val: number): void {
+  buf.data[y * buf.width + x] = val;
+}
+
+// Reusable temp buffer for Haar transforms — grown as needed
+let _haarTmp: Float64Array | null = null;
+
+function getHaarTmp(len: number): Float64Array {
+  if (!_haarTmp || _haarTmp.length < len) {
+    _haarTmp = new Float64Array(len);
+  }
+  return _haarTmp;
+}
+
+/**
+ * 1D Haar forward transform (in-place on a row/column slice)
+ */
+function haarForward1D(input: Float64Array, length: number): void {
+  const half = length >> 1;
+  const tmp = getHaarTmp(length);
+  const s = Math.SQRT1_2; // 1/sqrt(2)
+  for (let i = 0; i < half; i++) {
+    const a = input[2 * i];
+    const b = input[2 * i + 1];
+    tmp[i] = (a + b) * s;        // approximation (low)
+    tmp[half + i] = (a - b) * s; // detail (high)
+  }
+  for (let i = 0; i < length; i++) input[i] = tmp[i];
+}
+
+/**
+ * 1D Haar inverse transform (in-place on a row/column slice)
+ */
+function haarInverse1D(input: Float64Array, length: number): void {
+  const half = length >> 1;
+  const tmp = getHaarTmp(length);
+  const s = Math.SQRT1_2;
+  for (let i = 0; i < half; i++) {
+    const low = input[i];
+    const high = input[half + i];
+    tmp[2 * i] = (low + high) * s;
+    tmp[2 * i + 1] = (low - high) * s;
+  }
+  for (let i = 0; i < length; i++) input[i] = tmp[i];
+}
+
+/**
+ * Forward 2D Haar DWT (one level)
+ * Transforms the top-left (w x h) region of the buffer
+ */
+function dwtForward2DLevel(buf: Buffer2D, w: number, h: number): void {
+  // Transform rows
+  const rowBuf = new Float64Array(w);
+  for (let y = 0; y < h; y++) {
+    const off = y * buf.width;
+    for (let x = 0; x < w; x++) rowBuf[x] = buf.data[off + x];
+    haarForward1D(rowBuf, w);
+    for (let x = 0; x < w; x++) buf.data[off + x] = rowBuf[x];
+  }
+  // Transform columns
+  const colBuf = new Float64Array(h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) colBuf[y] = buf.data[y * buf.width + x];
+    haarForward1D(colBuf, h);
+    for (let y = 0; y < h; y++) buf.data[y * buf.width + x] = colBuf[y];
+  }
+}
+
+/**
+ * Inverse 2D Haar DWT (one level)
+ */
+function dwtInverse2DLevel(buf: Buffer2D, w: number, h: number): void {
+  // Inverse columns
+  const colBuf = new Float64Array(h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) colBuf[y] = buf.data[y * buf.width + x];
+    haarInverse1D(colBuf, h);
+    for (let y = 0; y < h; y++) buf.data[y * buf.width + x] = colBuf[y];
+  }
+  // Inverse rows
+  const rowBuf = new Float64Array(w);
+  for (let y = 0; y < h; y++) {
+    const off = y * buf.width;
+    for (let x = 0; x < w; x++) rowBuf[x] = buf.data[off + x];
+    haarInverse1D(rowBuf, w);
+    for (let x = 0; x < w; x++) buf.data[off + x] = rowBuf[x];
+  }
+}
+
+/**
+ * Extract a subband from the DWT buffer
+ * After one level of DWT on a (w x h) region:
+ *   LL = top-left (w/2 x h/2)
+ *   LH = top-right (w/2 x h/2) — vertical detail
+ *   HL = bottom-left (w/2 x h/2) — horizontal detail
+ *   HH = bottom-right (w/2 x h/2) — diagonal detail
+ */
+export function extractSubband(
+  buf: Buffer2D,
+  w: number,
+  h: number,
+  band: 'LL' | 'LH' | 'HL' | 'HH'
+): Buffer2D {
+  const hw = w >> 1;
+  const hh = h >> 1;
+  const offX = band === 'LH' || band === 'HH' ? hw : 0;
+  const offY = band === 'HL' || band === 'HH' ? hh : 0;
+  const out = createBuffer2D(hw, hh);
+  for (let y = 0; y < hh; y++) {
+    const srcOff = (offY + y) * buf.width + offX;
+    const dstOff = y * hw;
+    for (let x = 0; x < hw; x++) {
+      out.data[dstOff + x] = buf.data[srcOff + x];
+    }
+  }
+  return out;
+}
+
+/**
+ * Write a subband back into the DWT buffer
+ */
+export function writeSubband(
+  buf: Buffer2D,
+  w: number,
+  h: number,
+  band: 'LL' | 'LH' | 'HL' | 'HH',
+  subband: Buffer2D
+): void {
+  const hw = w >> 1;
+  const hh = h >> 1;
+  const offX = band === 'LH' || band === 'HH' ? hw : 0;
+  const offY = band === 'HL' || band === 'HH' ? hh : 0;
+  for (let y = 0; y < hh; y++) {
+    const dstOff = (offY + y) * buf.width + offX;
+    const srcOff = y * hw;
+    for (let x = 0; x < hw; x++) {
+      buf.data[dstOff + x] = subband.data[srcOff + x];
+    }
+  }
+}
+
+/**
+ * Multi-level forward DWT
+ * Returns the modified buffer and subband info for reconstruction
+ */
+export function dwtForward(input: Buffer2D, levels: number): { buf: Buffer2D; dims: Array<{ w: number; h: number }> } {
+  const buf = copyBuffer2D(input);
+  const dims: Array<{ w: number; h: number }> = [];
+  let w = buf.width;
+  let h = buf.height;
+
+  for (let l = 0; l < levels; l++) {
+    // Ensure even dimensions
+    w = w & ~1;
+    h = h & ~1;
+    dims.push({ w, h });
+    dwtForward2DLevel(buf, w, h);
+    w >>= 1;
+    h >>= 1;
+  }
+
+  return { buf, dims };
+}
+
+/**
+ * Multi-level inverse DWT
+ */
+export function dwtInverse(buf: Buffer2D, dims: Array<{ w: number; h: number }>): void {
+  for (let l = dims.length - 1; l >= 0; l--) {
+    const { w, h } = dims[l];
+    dwtInverse2DLevel(buf, w, h);
+  }
+}
+
+/**
+ * Convert a Uint8Array Y plane to a Float64 Buffer2D
+ */
+export function yPlaneToBuffer(yPlane: Uint8Array, width: number, height: number): Buffer2D {
+  const buf = createBuffer2D(width, height);
+  for (let i = 0; i < width * height; i++) {
+    buf.data[i] = yPlane[i];
+  }
+  return buf;
+}
+
+/**
+ * Convert a Float64 Buffer2D back to a Uint8Array Y plane (clamped to 0–255)
+ */
+export function bufferToYPlane(buf: Buffer2D): Uint8Array {
+  const out = new Uint8Array(buf.width * buf.height);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Math.max(0, Math.min(255, Math.round(buf.data[i])));
+  }
+  return out;
+}

core/embedder.ts

@@ -0,0 +1,187 @@
+/**
+ * High-level watermark embedder
+ *
+ * Takes a Y plane + payload + key + config → returns watermarked Y plane
+ */
+
+import type { WatermarkConfig, EmbedResult, Buffer2D } from './types.js';
+import { yPlaneToBuffer, bufferToYPlane, dwtForward, dwtInverse, extractSubband, writeSubband } from './dwt.js';
+import { dctForward8x8, dctInverse8x8, extractBlock, writeBlock, ZIGZAG_ORDER } from './dct.js';
+import { dmqimEmbed } from './dmqim.js';
+import { crcAppend } from './crc.js';
+import { BchCodec } from './bch.js';
+import { generateDithers, generatePermutation } from './keygen.js';
+import { computeTileGrid, getTileOrigin, getTileBlocks } from './tiling.js';
+import { blockAcEnergy, computeMaskingFactors } from './masking.js';
+
+/**
+ * Convert a 32-bit payload (4 bytes) to a bit array
+ */
+export function payloadToBits(payload: Uint8Array): Uint8Array {
+  const bits = new Uint8Array(payload.length * 8);
+  for (let i = 0; i < payload.length; i++) {
+    for (let b = 0; b < 8; b++) {
+      bits[i * 8 + b] = (payload[i] >> (7 - b)) & 1;
+    }
+  }
+  return bits;
+}
+
+/**
+ * Convert a bit array back to bytes
+ */
+export function bitsToPayload(bits: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(Math.ceil(bits.length / 8));
+  for (let i = 0; i < bits.length; i++) {
+    if (bits[i]) {
+      bytes[Math.floor(i / 8)] |= 1 << (7 - (i % 8));
+    }
+  }
+  return bytes;
+}
+
+/**
+ * Embed a watermark into a Y plane
+ */
+export function embedWatermark(
+  yPlane: Uint8Array,
+  width: number,
+  height: number,
+  payload: Uint8Array,
+  key: string,
+  config: WatermarkConfig
+): EmbedResult {
+  // Step 1: Encode payload
+  // Always use exactly 32 bits of payload, zero-pad the BCH message to fill k
+  const PAYLOAD_BITS = 32;
+  let payloadBits = payloadToBits(payload);
+  // Truncate or pad to exactly 32 bits
+  if (payloadBits.length < PAYLOAD_BITS) {
+    const padded = new Uint8Array(PAYLOAD_BITS);
+    padded.set(payloadBits);
+    payloadBits = padded;
+  } else if (payloadBits.length > PAYLOAD_BITS) {
+    payloadBits = payloadBits.subarray(0, PAYLOAD_BITS);
+  }
+  // CRC protects the 32-bit payload
+  const withCrc = crcAppend(payloadBits, config.crc.bits);
+  // Pad to fill BCH message length k
+  const bchMessage = new Uint8Array(config.bch.k);
+  bchMessage.set(withCrc);
+  const bch = new BchCodec(config.bch);
+  const encoded = bch.encode(bchMessage);
+  const codedLength = encoded.length;
+
+  // Generate interleaving permutation
+  const perm = generatePermutation(key, codedLength);
+  const interleaved = new Uint8Array(codedLength);
+  for (let i = 0; i < codedLength; i++) {
+    interleaved[perm[i]] = encoded[i];
+  }
+
+  // Step 2: Forward DWT
+  const buf = yPlaneToBuffer(yPlane, width, height);
+  const { buf: dwtBuf, dims } = dwtForward(buf, config.dwtLevels);
+
+  // Step 3: Extract HL subband at deepest level
+  // After N levels, the HL subband is in the bottom-left of the level-N region
+  let w = dims[dims.length - 1].w;
+  let h = dims[dims.length - 1].h;
+  for (let l = 0; l < config.dwtLevels - 1; l++) {
+    w >>= 1;
+    h >>= 1;
+  }
+  const hlSubband = extractSubband(dwtBuf, dims[dims.length - 1].w, dims[dims.length - 1].h, 'HL');
+
+  // Step 4: Set up tile grid
+  // tilePeriod is in spatial pixels; in subband it's tilePeriod / (2^levels)
+  const subbandTilePeriod = Math.floor(config.tilePeriod / (1 << config.dwtLevels));
+  const tileGrid = computeTileGrid(hlSubband.width, hlSubband.height, subbandTilePeriod);
+
+  if (tileGrid.totalTiles === 0) {
+    // Frame too small for any tiles — return unchanged
+    return { yPlane: new Uint8Array(yPlane), psnr: Infinity };
+  }
+
+  // Step 5: Generate dithers — same sequence reused per tile so each tile
+  // is independently decodable (required for crop robustness)
+  const coeffsPerBlock = config.zigzagPositions.length;
+  const maxCoeffsPerTile = 1024; // Upper bound
+  const dithers = generateDithers(key, maxCoeffsPerTile, config.delta);
+
+  // Step 6: For each tile, embed the coded bits
+  // Reusable block buffer to avoid allocation per block
+  const blockBuf = new Float64Array(64);
+
+  // Precompute zigzag → coefficient index mapping
+  const zigCoeffIdx = new Int32Array(config.zigzagPositions.length);
+  for (let z = 0; z < config.zigzagPositions.length; z++) {
+    const [r, c] = ZIGZAG_ORDER[config.zigzagPositions[z]];
+    zigCoeffIdx[z] = r * 8 + c;
+  }
+
+  for (let tileIdx = 0; tileIdx < tileGrid.totalTiles; tileIdx++) {
+    let ditherIdx = 0; // Reset per tile — each tile uses same dither sequence
+    const origin = getTileOrigin(tileGrid, tileIdx);
+    const blocks = getTileBlocks(origin.x, origin.y, subbandTilePeriod, hlSubband.width, hlSubband.height);
+
+    // Compute masking factors if enabled
+    let maskingFactors: Float64Array | null = null;
+    if (config.perceptualMasking && blocks.length > 0) {
+      const energies = new Float64Array(blocks.length);
+      for (let bi = 0; bi < blocks.length; bi++) {
+        extractBlock(hlSubband.data, hlSubband.width, blocks[bi].row, blocks[bi].col, blockBuf);
+        dctForward8x8(blockBuf);
+        energies[bi] = blockAcEnergy(blockBuf);
+      }
+      maskingFactors = computeMaskingFactors(energies);
+    }
+
+    let bitIdx = 0;
+    for (let bi = 0; bi < blocks.length; bi++) {
+      const { row, col } = blocks[bi];
+      extractBlock(hlSubband.data, hlSubband.width, row, col, blockBuf);
+
+      // Forward DCT
+      dctForward8x8(blockBuf);
+
+      const maskFactor = maskingFactors ? maskingFactors[bi] : 1.0;
+      const effectiveDelta = config.delta * maskFactor;
+
+      // Embed bits into selected zigzag positions
+      for (let z = 0; z < zigCoeffIdx.length; z++) {
+        if (bitIdx >= codedLength) bitIdx = 0; // Repeat pattern
+
+        const coeffIdx = zigCoeffIdx[z];
+        const bit = interleaved[bitIdx];
+        const dither = dithers[ditherIdx++];
+
+        blockBuf[coeffIdx] = dmqimEmbed(blockBuf[coeffIdx], bit, effectiveDelta, dither);
+
+        bitIdx++;
+      }
+
+      // Inverse DCT and write back
+      dctInverse8x8(blockBuf);
+      writeBlock(hlSubband.data, hlSubband.width, row, col, blockBuf);
+    }
+  }
+
+  // Step 7: Write modified HL subband back and inverse DWT
+  writeSubband(dwtBuf, dims[dims.length - 1].w, dims[dims.length - 1].h, 'HL', hlSubband);
+  dwtInverse(dwtBuf, dims);
+
+  // Convert back to Y plane
+  const watermarkedY = bufferToYPlane(dwtBuf);
+
+  // Compute PSNR
+  let mse = 0;
+  for (let i = 0; i < yPlane.length; i++) {
+    const diff = yPlane[i] - watermarkedY[i];
+    mse += diff * diff;
+  }
+  mse /= yPlane.length;
+  const psnr = mse > 0 ? 10 * Math.log10(255 * 255 / mse) : Infinity;
+
+  return { yPlane: watermarkedY, psnr };
+}

core/keygen.ts

@@ -0,0 +1,129 @@
+/**
+ * Key derivation and PRNG for watermark embedding
+ *
+ * Uses a simple but effective approach: derive deterministic
+ * pseudo-random sequences from a secret key using a seeded PRNG.
+ * For browser compatibility, we use a pure-JS implementation.
+ */
+
+/**
+ * Simple hash function (djb2 variant) for string to 32-bit seed
+ */
+function hashString(str: string): number {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
+  }
+  return hash >>> 0;
+}
+
+/**
+ * Mix two 32-bit values (MurmurHash3 finalizer)
+ */
+function mix(h: number): number {
+  h = ((h >>> 16) ^ h) * 0x45d9f3b | 0;
+  h = ((h >>> 16) ^ h) * 0x45d9f3b | 0;
+  h = (h >>> 16) ^ h;
+  return h >>> 0;
+}
+
+/**
+ * Seeded PRNG (xorshift128)
+ * Produces deterministic sequences from a seed
+ */
+export class SeededPRNG {
+  private s0: number;
+  private s1: number;
+  private s2: number;
+  private s3: number;
+
+  constructor(seed: number) {
+    // Initialize state from seed using splitmix32
+    this.s0 = seed | 0;
+    this.s1 = mix(seed + 1);
+    this.s2 = mix(seed + 2);
+    this.s3 = mix(seed + 3);
+
+    // Warm up
+    for (let i = 0; i < 20; i++) this.next();
+  }
+
+  /** Get next random 32-bit unsigned integer */
+  next(): number {
+    let t = this.s3;
+    const s = this.s0;
+    this.s3 = this.s2;
+    this.s2 = this.s1;
+    this.s1 = s;
+    t ^= t << 11;
+    t ^= t >>> 8;
+    this.s0 = t ^ s ^ (s >>> 19);
+    return this.s0 >>> 0;
+  }
+
+  /** Get random float in [0, 1) */
+  nextFloat(): number {
+    return this.next() / 0x100000000;
+  }
+
+  /** Get random float in [min, max) */
+  nextRange(min: number, max: number): number {
+    return min + this.nextFloat() * (max - min);
+  }
+
+  /** Get random integer in [0, max) */
+  nextInt(max: number): number {
+    return (this.next() % max) >>> 0;
+  }
+}
+
+/**
+ * Derive a seed from key + purpose string
+ */
+export function deriveSeed(key: string, purpose: string): number {
+  const combined = key + ':' + purpose;
+  return mix(hashString(combined));
+}
+
+/**
+ * Generate dither values for DM-QIM embedding
+ * Returns array of dither values in [-delta/2, +delta/2]
+ */
+export function generateDithers(key: string, count: number, delta: number): Float64Array {
+  const prng = new SeededPRNG(deriveSeed(key, 'dither'));
+  const dithers = new Float64Array(count);
+  for (let i = 0; i < count; i++) {
+    dithers[i] = prng.nextRange(-delta / 2, delta / 2);
+  }
+  return dithers;
+}
+
+/**
+ * Generate a permutation (Fisher-Yates) for bit interleaving
+ */
+export function generatePermutation(key: string, length: number): Uint32Array {
+  const prng = new SeededPRNG(deriveSeed(key, 'permutation'));
+  const perm = new Uint32Array(length);
+  for (let i = 0; i < length; i++) perm[i] = i;
+
+  for (let i = length - 1; i > 0; i--) {
+    const j = prng.nextInt(i + 1);
+    const tmp = perm[i];
+    perm[i] = perm[j];
+    perm[j] = tmp;
+  }
+
+  return perm;
+}
+
+/**
+ * Generate inverse permutation
+ */
+export function generateInversePermutation(key: string, length: number): Uint32Array {
+  const perm = generatePermutation(key, length);
+  const inv = new Uint32Array(length);
+  for (let i = 0; i < length; i++) {
+    inv[perm[i]] = i;
+  }
+  return inv;
+}

core/masking.ts

@@ -0,0 +1,54 @@
+/**
+ * Perceptual masking — adapt watermark strength based on local image content
+ *
+ * High-energy (textured) areas can tolerate stronger watermarks,
+ * while smooth areas need weaker embedding to remain imperceptible.
+ */
+
+/**
+ * Compute AC energy of an 8x8 DCT block (sum of squared AC coefficients)
+ * Assumes the block is already in DCT domain.
+ */
+export function blockAcEnergy(dctBlock: Float64Array): number {
+  let energy = 0;
+  for (let i = 1; i < 64; i++) { // Skip DC (index 0)
+    energy += dctBlock[i] * dctBlock[i];
+  }
+  return energy;
+}
+
+/**
+ * Compute perceptual masking factors for a set of DCT blocks
+ *
+ * Returns per-block multiplier for delta:
+ *   Δ_effective = Δ_base × masking_factor
+ *
+ * Factors are in [0.5, 2.0]:
+ *   - Smooth blocks → factor < 1 (reduce strength)
+ *   - Textured blocks → factor > 1 (can increase strength)
+ *
+ * @param blockEnergies - AC energy for each block
+ * @returns Array of masking factors, same length as input
+ */
+export function computeMaskingFactors(blockEnergies: Float64Array): Float64Array {
+  const n = blockEnergies.length;
+  if (n === 0) return new Float64Array(0);
+
+  // Compute median energy
+  const sorted = new Float64Array(blockEnergies).sort();
+  const median = n % 2 === 0
+    ? (sorted[n / 2 - 1] + sorted[n / 2]) / 2
+    : sorted[Math.floor(n / 2)];
+
+  // Avoid division by zero
+  const safeMedian = Math.max(median, 1e-6);
+
+  const factors = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    const ratio = blockEnergies[i] / safeMedian;
+    // Clamp to [0.5, 2.0]
+    factors[i] = Math.max(0.5, Math.min(2.0, ratio));
+  }
+
+  return factors;
+}

core/presets.ts

@@ -0,0 +1,77 @@
+import type { PresetName, WatermarkConfig } from './types.js';
+
+/** Mid-frequency DCT coefficients (zigzag positions 3–14, 12 coeffs) */
+const MID_FREQ_ZIGZAG = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];
+
+/** Low+mid frequency coefficients (zigzag 1–20, 20 coeffs) — survive heavy compression */
+const LOW_MID_FREQ_ZIGZAG = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+
+/** Low frequency coefficients (zigzag 1–10, 10 coeffs) — survive extreme compression */
+const LOW_FREQ_ZIGZAG = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+export const PRESETS: Record<PresetName, WatermarkConfig> = {
+  light: {
+    alpha: 0.10,
+    delta: 50,
+    tilePeriod: 256,
+    bch: { n: 63, k: 36, t: 5, m: 6 },
+    crc: { bits: 4 },
+    dwtLevels: 2,
+    zigzagPositions: MID_FREQ_ZIGZAG,
+    perceptualMasking: false,
+    temporalFrames: 1,
+  },
+
+  moderate: {
+    alpha: 0.18,
+    delta: 80,
+    tilePeriod: 232,
+    bch: { n: 63, k: 36, t: 5, m: 6 },
+    crc: { bits: 4 },
+    dwtLevels: 2,
+    zigzagPositions: MID_FREQ_ZIGZAG,
+    perceptualMasking: true,
+    temporalFrames: 1,
+  },
+
+  strong: {
+    alpha: 0.26,
+    delta: 110,
+    tilePeriod: 208,
+    bch: { n: 63, k: 36, t: 5, m: 6 },
+    crc: { bits: 4 },
+    dwtLevels: 2,
+    zigzagPositions: LOW_MID_FREQ_ZIGZAG,
+    perceptualMasking: true,
+    temporalFrames: 1,
+  },
+
+  fortress: {
+    alpha: 0.35,
+    delta: 150,
+    tilePeriod: 192,
+    bch: { n: 63, k: 36, t: 5, m: 6 },
+    crc: { bits: 4 },
+    dwtLevels: 2,
+    zigzagPositions: LOW_MID_FREQ_ZIGZAG,
+    perceptualMasking: true,
+    temporalFrames: 1,
+  },
+};
+
+/**
+ * Get a preset configuration by name
+ */
+export function getPreset(name: PresetName): WatermarkConfig {
+  return { ...PRESETS[name] };
+}
+
+/**
+ * Preset descriptions for the UI
+ */
+export const PRESET_DESCRIPTIONS: Record<PresetName, string> = {
+  light: '🌤️ Lightest touch. Near-invisible, survives mild compression.',
+  moderate: '⚡ Balanced embedding with perceptual masking. Good compression resilience.',
+  strong: '🛡️ Stronger embedding across more frequencies. Handles rescaling well.',
+  fortress: '🏰 Maximum robustness. Survives heavy compression and color adjustments.',
+};

core/tiling.ts

@@ -0,0 +1,178 @@
+/**
+ * Tile layout and autocorrelation-based sync recovery
+ *
+ * The watermark is embedded as a periodic pattern of tiles.
+ * Each tile contains one complete copy of the coded payload.
+ * During detection, autocorrelation recovers the tile grid
+ * even after cropping.
+ */
+
+import type { Buffer2D } from './types.js';
+
+/** Tile grid description */
+export interface TileGrid {
+  /** Tile period in subband pixels */
+  tilePeriod: number;
+  /** Phase offset X (for cropped frames) */
+  phaseX: number;
+  /** Phase offset Y (for cropped frames) */
+  phaseY: number;
+  /** Number of complete tiles in X direction */
+  tilesX: number;
+  /** Number of complete tiles in Y direction */
+  tilesY: number;
+  /** Total number of tiles */
+  totalTiles: number;
+}
+
+/**
+ * Compute the tile grid for a given subband size and tile period
+ * During embedding, phase is always (0, 0)
+ */
+export function computeTileGrid(
+  subbandWidth: number,
+  subbandHeight: number,
+  tilePeriod: number
+): TileGrid {
+  const tilesX = Math.floor(subbandWidth / tilePeriod);
+  const tilesY = Math.floor(subbandHeight / tilePeriod);
+  return {
+    tilePeriod,
+    phaseX: 0,
+    phaseY: 0,
+    tilesX,
+    tilesY,
+    totalTiles: tilesX * tilesY,
+  };
+}
+
+/**
+ * Get the subband region for a specific tile
+ * Returns [startX, startY] in subband coordinates
+ */
+export function getTileOrigin(grid: TileGrid, tileIdx: number): { x: number; y: number } {
+  const tileCol = tileIdx % grid.tilesX;
+  const tileRow = Math.floor(tileIdx / grid.tilesX);
+  return {
+    x: grid.phaseX + tileCol * grid.tilePeriod,
+    y: grid.phaseY + tileRow * grid.tilePeriod,
+  };
+}
+
+/**
+ * Compute 8x8 DCT block positions within a tile
+ * Returns array of [blockRow, blockCol] in subband coordinates
+ */
+export function getTileBlocks(
+  tileOriginX: number,
+  tileOriginY: number,
+  tilePeriod: number,
+  subbandWidth: number,
+  subbandHeight: number
+): Array<{ row: number; col: number }> {
+  const blocks: Array<{ row: number; col: number }> = [];
+  const blocksPerTileSide = Math.floor(tilePeriod / 8);
+
+  for (let br = 0; br < blocksPerTileSide; br++) {
+    for (let bc = 0; bc < blocksPerTileSide; bc++) {
+      const absRow = Math.floor(tileOriginY / 8) + br;
+      const absCol = Math.floor(tileOriginX / 8) + bc;
+      // Ensure the block fits within the subband
+      if ((absRow + 1) * 8 <= subbandHeight && (absCol + 1) * 8 <= subbandWidth) {
+        blocks.push({ row: absRow, col: absCol });
+      }
+    }
+  }
+
+  return blocks;
+}
+
+/**
+ * Autocorrelation-based tile period and phase recovery
+ *
+ * Computes 2D autocorrelation of the subband energy pattern
+ * to find the periodic tile structure.
+ */
+export function recoverTileGrid(
+  subband: Buffer2D,
+  expectedTilePeriod: number,
+  searchRange: number = 4
+): TileGrid {
+  const { data, width, height } = subband;
+
+  // Compute block energy map (8x8 blocks)
+  const bw = Math.floor(width / 8);
+  const bh = Math.floor(height / 8);
+  const energy = new Float64Array(bw * bh);
+
+  for (let by = 0; by < bh; by++) {
+    for (let bx = 0; bx < bw; bx++) {
+      let e = 0;
+      for (let r = 0; r < 8; r++) {
+        for (let c = 0; c < 8; c++) {
+          const v = data[(by * 8 + r) * width + (bx * 8 + c)];
+          e += v * v;
+        }
+      }
+      energy[by * bw + bx] = e;
+    }
+  }
+
+  // Expected tile period in blocks
+  const expectedBlockPeriod = Math.floor(expectedTilePeriod / 8);
+
+  // Search for the best period near the expected value
+  let bestPeriod = expectedBlockPeriod;
+  let bestCorr = -Infinity;
+  let bestPhaseX = 0;
+  let bestPhaseY = 0;
+
+  for (let p = expectedBlockPeriod - searchRange; p <= expectedBlockPeriod + searchRange; p++) {
+    if (p < 2) continue;
+
+    // For each candidate phase offset
+    for (let py = 0; py < p; py++) {
+      for (let px = 0; px < p; px++) {
+        let corr = 0;
+        let count = 0;
+
+        // Compute autocorrelation at this period and phase
+        for (let by = py; by + p < bh; by += p) {
+          for (let bx = px; bx + p < bw; bx += p) {
+            const e1 = energy[by * bw + bx];
+            const e2 = energy[(by + p) * bw + bx];
+            const e3 = energy[by * bw + (bx + p)];
+            corr += e1 * e2 + e1 * e3;
+            count++;
+          }
+        }
+
+        if (count > 0) {
+          corr /= count;
+          if (corr > bestCorr) {
+            bestCorr = corr;
+            bestPeriod = p;
+            bestPhaseX = px;
+            bestPhaseY = py;
+          }
+        }
+      }
+    }
+  }
+
+  // Convert from block coordinates back to subband pixels
+  const tilePeriod = bestPeriod * 8;
+  const phaseX = bestPhaseX * 8;
+  const phaseY = bestPhaseY * 8;
+  const tilesX = Math.floor((width - phaseX) / tilePeriod);
+  const tilesY = Math.floor((height - phaseY) / tilePeriod);
+
+  return {
+    tilePeriod,
+    phaseX,
+    phaseY,
+    tilesX,
+    tilesY,
+    totalTiles: tilesX * tilesY,
+  };
+}

core/types.ts

@@ -0,0 +1,81 @@
+/** Watermark preset names */
+export type PresetName = 'light' | 'moderate' | 'strong' | 'fortress';
+
+/** BCH code parameters */
+export interface BchParams {
+  /** Codeword length */
+  n: number;
+  /** Message length */
+  k: number;
+  /** Error correction capability */
+  t: number;
+  /** Galois field order m (GF(2^m)) */
+  m: number;
+}
+
+/** CRC configuration */
+export interface CrcConfig {
+  /** CRC bit width (4, 8, or 16) */
+  bits: 4 | 8 | 16;
+}
+
+/** Full watermark configuration */
+export interface WatermarkConfig {
+  /** Embedding strength multiplier (0–1) */
+  alpha: number;
+  /** QIM quantization step */
+  delta: number;
+  /** Tile period in pixels (spatial domain) */
+  tilePeriod: number;
+  /** BCH code parameters */
+  bch: BchParams;
+  /** CRC configuration */
+  crc: CrcConfig;
+  /** DWT decomposition levels */
+  dwtLevels: number;
+  /** Zigzag coefficient positions to use within 8x8 DCT blocks */
+  zigzagPositions: number[];
+  /** Enable perceptual masking */
+  perceptualMasking: boolean;
+  /** Number of frames to average for temporal detection (1 = single frame) */
+  temporalFrames: number;
+}
+
+/** Detection result */
+export interface DetectionResult {
+  /** Whether a watermark was detected */
+  detected: boolean;
+  /** Decoded payload (null if not detected) */
+  payload: Uint8Array | null;
+  /** Detection confidence (0–1) */
+  confidence: number;
+  /** Number of tiles successfully decoded */
+  tilesDecoded: number;
+  /** Total tiles found */
+  tilesTotal: number;
+}
+
+/** Embedding result */
+export interface EmbedResult {
+  /** Watermarked Y plane */
+  yPlane: Uint8Array;
+  /** PSNR of the watermarked frame relative to original (dB) */
+  psnr: number;
+}
+
+/** 2D buffer for signal processing (row-major Float64Array) */
+export interface Buffer2D {
+  data: Float64Array;
+  width: number;
+  height: number;
+}
+
+/** DWT decomposition result */
+export interface DwtResult {
+  /** All subbands at each level: [level][LL, LH, HL, HH] */
+  subbands: Buffer2D[][];
+  /** Original dimensions at each level */
+  dimensions: Array<{ width: number; height: number }>;
+  /** Number of decomposition levels */
+  levels: number;
+}

package-lock.json

@@ -0,0 +1,2826 @@
+{
+  "name": "ltmarx",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "ltmarx",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "@ffmpeg/ffmpeg": "^0.12.15",
+        "@ffmpeg/util": "^0.12.2",
+        "react": "^19.2.4",
+        "react-dom": "^19.2.4"
+      },
+      "bin": {
+        "ltmarx": "dist/server/cli.js"
+      },
+      "devDependencies": {
+        "@tailwindcss/vite": "^4.2.1",
+        "@types/node": "^25.3.0",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "@vitejs/plugin-react": "^5.1.4",
+        "tailwindcss": "^4.2.1",
+        "typescript": "^5.9.3",
+        "vite": "^7.3.1",
+        "vitest": "^4.0.18"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz",
+      "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz",
+      "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
+      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
+      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
+      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
+      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
+      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
+      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
+      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
+      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
+      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
+      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
+      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
+      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
+      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
+      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
+      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
+      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
+      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
+      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
+      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
+      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
+      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
+      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
+      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@ffmpeg/ffmpeg": {
+      "version": "0.12.15",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/ffmpeg/-/ffmpeg-0.12.15.tgz",
+      "integrity": "sha512-1C8Obr4GsN3xw+/1Ww6PFM84wSQAGsdoTuTWPOj2OizsRDLT4CXTaVjPhkw6ARyDus1B9X/L2LiXHqYYsGnRFw==",
+      "license": "MIT",
+      "dependencies": {
+        "@ffmpeg/types": "^0.12.4"
+      },
+      "engines": {
+        "node": ">=18.x"
+      }
+    },
+    "node_modules/@ffmpeg/types": {
+      "version": "0.12.4",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/types/-/types-0.12.4.tgz",
+      "integrity": "sha512-k9vJQNBGTxE5AhYDtOYR5rO5fKsspbg51gbcwtbkw2lCdoIILzklulcjJfIDwrtn7XhDeF2M+THwJ2FGrLeV6A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
+    "node_modules/@ffmpeg/util": {
+      "version": "0.12.2",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/util/-/util-0.12.2.tgz",
+      "integrity": "sha512-ouyoW+4JB7WxjeZ2y6KpRvB+dLp7Cp4ro8z0HIVpZVCM7AwFlHa0c4R8Y/a4M3wMqATpYKhC7lSFHQ0T11MEDw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.x"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz",
+      "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
+      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
+      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
+      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
+      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
+      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
+      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
+      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
+      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
+      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
+      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
+      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
+      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
+      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
+      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
+      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
+      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
+      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
+      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
+      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
+      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
+      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
+      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.2.1.tgz",
+      "integrity": "sha512-jlx6sLk4EOwO6hHe1oCGm1Q4AN/s0rSrTTPBGPM0/RQ6Uylwq17FuU8IeJJKEjtc6K6O07zsvP+gDO6MMWo7pg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "enhanced-resolve": "^5.19.0",
+        "jiti": "^2.6.1",
+        "lightningcss": "1.31.1",
+        "magic-string": "^0.30.21",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.2.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.2.1.tgz",
+      "integrity": "sha512-yv9jeEFWnjKCI6/T3Oq50yQEOqmpmpfzG1hcZsAOaXFQPfzWprWrlHSdGPEF3WQTi8zu8ohC9Mh9J470nT5pUw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.2.1",
+        "@tailwindcss/oxide-darwin-arm64": "4.2.1",
+        "@tailwindcss/oxide-darwin-x64": "4.2.1",
+        "@tailwindcss/oxide-freebsd-x64": "4.2.1",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.1",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.2.1",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.2.1",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.2.1",
+        "@tailwindcss/oxide-linux-x64-musl": "4.2.1",
+        "@tailwindcss/oxide-wasm32-wasi": "4.2.1",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.2.1",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.2.1"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.2.1.tgz",
+      "integrity": "sha512-eZ7G1Zm5EC8OOKaesIKuw77jw++QJ2lL9N+dDpdQiAB/c/B2wDh0QPFHbkBVrXnwNugvrbJFk1gK2SsVjwWReg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.2.1.tgz",
+      "integrity": "sha512-q/LHkOstoJ7pI1J0q6djesLzRvQSIfEto148ppAd+BVQK0JYjQIFSK3JgYZJa+Yzi0DDa52ZsQx2rqytBnf8Hw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.2.1.tgz",
+      "integrity": "sha512-/f/ozlaXGY6QLbpvd/kFTro2l18f7dHKpB+ieXz+Cijl4Mt9AI2rTrpq7V+t04nK+j9XBQHnSMdeQRhbGyt6fw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.2.1.tgz",
+      "integrity": "sha512-5e/AkgYJT/cpbkys/OU2Ei2jdETCLlifwm7ogMC7/hksI2fC3iiq6OcXwjibcIjPung0kRtR3TxEITkqgn0TcA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.2.1.tgz",
+      "integrity": "sha512-Uny1EcVTTmerCKt/1ZuKTkb0x8ZaiuYucg2/kImO5A5Y/kBz41/+j0gxUZl+hTF3xkWpDmHX+TaWhOtba2Fyuw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.2.1.tgz",
+      "integrity": "sha512-CTrwomI+c7n6aSSQlsPL0roRiNMDQ/YzMD9EjcR+H4f0I1SQ8QqIuPnsVp7QgMkC1Qi8rtkekLkOFjo7OlEFRQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.2.1.tgz",
+      "integrity": "sha512-WZA0CHRL/SP1TRbA5mp9htsppSEkWuQ4KsSUumYQnyl8ZdT39ntwqmz4IUHGN6p4XdSlYfJwM4rRzZLShHsGAQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.2.1.tgz",
+      "integrity": "sha512-qMFzxI2YlBOLW5PhblzuSWlWfwLHaneBE0xHzLrBgNtqN6mWfs+qYbhryGSXQjFYB1Dzf5w+LN5qbUTPhW7Y5g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.2.1.tgz",
+      "integrity": "sha512-5r1X2FKnCMUPlXTWRYpHdPYUY6a1Ar/t7P24OuiEdEOmms5lyqjDRvVY1yy9Rmioh+AunQ0rWiOTPE8F9A3v5g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.2.1.tgz",
+      "integrity": "sha512-MGFB5cVPvshR85MTJkEvqDUnuNoysrsRxd6vnk1Lf2tbiqNlXpHYZqkqOQalydienEWOHHFyyuTSYRsLfxFJ2Q==",
+      "bundleDependencies": [
+        "@napi-rs/wasm-runtime",
+        "@emnapi/core",
+        "@emnapi/runtime",
+        "@tybys/wasm-util",
+        "@emnapi/wasi-threads",
+        "tslib"
+      ],
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.8.1",
+        "@emnapi/runtime": "^1.8.1",
+        "@emnapi/wasi-threads": "^1.1.0",
+        "@napi-rs/wasm-runtime": "^1.1.1",
+        "@tybys/wasm-util": "^0.10.1",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.2.1.tgz",
+      "integrity": "sha512-YlUEHRHBGnCMh4Nj4GnqQyBtsshUPdiNroZj8VPkvTZSoHsilRCwXcVKnG9kyi0ZFAS/3u+qKHBdDc81SADTRA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.2.1.tgz",
+      "integrity": "sha512-rbO34G5sMWWyrN/idLeVxAZgAKWrn5LiR3/I90Q9MkA67s6T1oB0xtTe+0heoBvHSpbU9Mk7i6uwJnpo4u21XQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@tailwindcss/vite": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.2.1.tgz",
+      "integrity": "sha512-TBf2sJjYeb28jD2U/OhwdW0bbOsxkWPwQ7SrqGf9sVcoYwZj7rkXljroBO9wKBut9XnmQLXanuDUeqQK0lGg/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@tailwindcss/node": "4.2.1",
+        "@tailwindcss/oxide": "4.2.1",
+        "tailwindcss": "4.2.1"
+      },
+      "peerDependencies": {
+        "vite": "^5.2.0 || ^6 || ^7"
+      }
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "25.3.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.0.tgz",
+      "integrity": "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.18.0"
+      }
+    },
+    "node_modules/@types/react": {
+      "version": "19.2.14",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+      "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.2.3",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+      "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/react": "^19.2.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.1.4",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.4.tgz",
+      "integrity": "sha512-VIcFLdRi/VYRU8OL/puL7QXMYafHmqOnwTZY50U1JPlCNj30PxCMx65c494b1K9be9hX83KVt0+gTEwTWLqToA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.29.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-rc.3",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.18.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.0.18.tgz",
+      "integrity": "sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "chai": "^6.2.1",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.0.18.tgz",
+      "integrity": "sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.0.18",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.0.18.tgz",
+      "integrity": "sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.0.18.tgz",
+      "integrity": "sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.0.18",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.0.18.tgz",
+      "integrity": "sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.0.18.tgz",
+      "integrity": "sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.0.18.tgz",
+      "integrity": "sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.0.18",
+        "tinyrainbow": "^3.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz",
+      "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.1",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz",
+      "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.9.0",
+        "caniuse-lite": "^1.0.30001759",
+        "electron-to-chromium": "^1.5.263",
+        "node-releases": "^2.0.27",
+        "update-browserslist-db": "^1.2.0"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001774",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001774.tgz",
+      "integrity": "sha512-DDdwPGz99nmIEv216hKSgLD+D4ikHQHjBC/seF98N9CPqRX4M5mSxT9eTV6oyisnJcuzxtZy4n17yKKQYmYQOA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.302",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.302.tgz",
+      "integrity": "sha512-sM6HAN2LyK82IyPBpznDRqlTQAtuSaO+ShzFiWTvoMJLHyZ+Y39r8VMfHzwbU8MVBzQ4Wdn85+wlZl2TLGIlwg==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.19.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz",
+      "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.0"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.3",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
+      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.3",
+        "@esbuild/android-arm": "0.27.3",
+        "@esbuild/android-arm64": "0.27.3",
+        "@esbuild/android-x64": "0.27.3",
+        "@esbuild/darwin-arm64": "0.27.3",
+        "@esbuild/darwin-x64": "0.27.3",
+        "@esbuild/freebsd-arm64": "0.27.3",
+        "@esbuild/freebsd-x64": "0.27.3",
+        "@esbuild/linux-arm": "0.27.3",
+        "@esbuild/linux-arm64": "0.27.3",
+        "@esbuild/linux-ia32": "0.27.3",
+        "@esbuild/linux-loong64": "0.27.3",
+        "@esbuild/linux-mips64el": "0.27.3",
+        "@esbuild/linux-ppc64": "0.27.3",
+        "@esbuild/linux-riscv64": "0.27.3",
+        "@esbuild/linux-s390x": "0.27.3",
+        "@esbuild/linux-x64": "0.27.3",
+        "@esbuild/netbsd-arm64": "0.27.3",
+        "@esbuild/netbsd-x64": "0.27.3",
+        "@esbuild/openbsd-arm64": "0.27.3",
+        "@esbuild/openbsd-x64": "0.27.3",
+        "@esbuild/openharmony-arm64": "0.27.3",
+        "@esbuild/sunos-x64": "0.27.3",
+        "@esbuild/win32-arm64": "0.27.3",
+        "@esbuild/win32-ia32": "0.27.3",
+        "@esbuild/win32-x64": "0.27.3"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/jiti": {
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
+      "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.31.1.tgz",
+      "integrity": "sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.31.1",
+        "lightningcss-darwin-arm64": "1.31.1",
+        "lightningcss-darwin-x64": "1.31.1",
+        "lightningcss-freebsd-x64": "1.31.1",
+        "lightningcss-linux-arm-gnueabihf": "1.31.1",
+        "lightningcss-linux-arm64-gnu": "1.31.1",
+        "lightningcss-linux-arm64-musl": "1.31.1",
+        "lightningcss-linux-x64-gnu": "1.31.1",
+        "lightningcss-linux-x64-musl": "1.31.1",
+        "lightningcss-win32-arm64-msvc": "1.31.1",
+        "lightningcss-win32-x64-msvc": "1.31.1"
+      }
+    },
+    "node_modules/lightningcss-android-arm64": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.31.1.tgz",
+      "integrity": "sha512-HXJF3x8w9nQ4jbXRiNppBCqeZPIAfUo8zE/kOEGbW5NZvGc/K7nMxbhIr+YlFlHW5mpbg/YFPdbnCh1wAXCKFg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.31.1.tgz",
+      "integrity": "sha512-02uTEqf3vIfNMq3h/z2cJfcOXnQ0GRwQrkmPafhueLb2h7mqEidiCzkE4gBMEH65abHRiQvhdcQ+aP0D0g67sg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.31.1.tgz",
+      "integrity": "sha512-1ObhyoCY+tGxtsz1lSx5NXCj3nirk0Y0kB/g8B8DT+sSx4G9djitg9ejFnjb3gJNWo7qXH4DIy2SUHvpoFwfTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.31.1.tgz",
+      "integrity": "sha512-1RINmQKAItO6ISxYgPwszQE1BrsVU5aB45ho6O42mu96UiZBxEXsuQ7cJW4zs4CEodPUioj/QrXW1r9pLUM74A==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.31.1.tgz",
+      "integrity": "sha512-OOCm2//MZJ87CdDK62rZIu+aw9gBv4azMJuA8/KB74wmfS3lnC4yoPHm0uXZ/dvNNHmnZnB8XLAZzObeG0nS1g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.31.1.tgz",
+      "integrity": "sha512-WKyLWztD71rTnou4xAD5kQT+982wvca7E6QoLpoawZ1gP9JM0GJj4Tp5jMUh9B3AitHbRZ2/H3W5xQmdEOUlLg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.31.1.tgz",
+      "integrity": "sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.31.1.tgz",
+      "integrity": "sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.31.1.tgz",
+      "integrity": "sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.31.1.tgz",
+      "integrity": "sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.31.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.31.1.tgz",
+      "integrity": "sha512-I9aiFrbd7oYHwlnQDqr1Roz+fTz61oDDJX7n9tYF9FJymH1cIN1DtKw3iYt6b8WZgEjoNwVSncwF4wx/ZedMhw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.27",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+      "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.6",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+      "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
+      "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.4",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz",
+      "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.4"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
+      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.59.0",
+        "@rollup/rollup-android-arm64": "4.59.0",
+        "@rollup/rollup-darwin-arm64": "4.59.0",
+        "@rollup/rollup-darwin-x64": "4.59.0",
+        "@rollup/rollup-freebsd-arm64": "4.59.0",
+        "@rollup/rollup-freebsd-x64": "4.59.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-musl": "4.59.0",
+        "@rollup/rollup-openbsd-x64": "4.59.0",
+        "@rollup/rollup-openharmony-arm64": "4.59.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
+      "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tailwindcss": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.2.1.tgz",
+      "integrity": "sha512-/tBrSQ36vCleJkAOsy9kbNTgaxvGbyOamC30PRePTQe/o1MFwEKHQk4Cn7BNGaPtjp+PuUrByJehM1hgxfq4sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tapable": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",
+      "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
+      "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.0.3.tgz",
+      "integrity": "sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+      "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.0.18",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.0.18.tgz",
+      "integrity": "sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.0.18",
+        "@vitest/mocker": "4.0.18",
+        "@vitest/pretty-format": "4.0.18",
+        "@vitest/runner": "4.0.18",
+        "@vitest/snapshot": "4.0.18",
+        "@vitest/spy": "4.0.18",
+        "@vitest/utils": "4.0.18",
+        "es-module-lexer": "^1.7.0",
+        "expect-type": "^1.2.2",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^3.10.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.0.3",
+        "vite": "^6.0.0 || ^7.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.0.18",
+        "@vitest/browser-preview": "4.0.18",
+        "@vitest/browser-webdriverio": "4.0.18",
+        "@vitest/ui": "4.0.18",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    }
+  }
+}

package.json

@@ -0,0 +1,34 @@
+{
+  "name": "ltmarx",
+  "version": "1.0.0",
+  "description": "Video watermarking system with imperceptible 32-bit payload embedding",
+  "type": "module",
+  "bin": {
+    "ltmarx": "./dist/server/cli.js"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "build:cli": "tsc -p tsconfig.server.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.2.1",
+    "@types/node": "^25.3.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.4",
+    "tailwindcss": "^4.2.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@ffmpeg/ffmpeg": "^0.12.15",
+    "@ffmpeg/util": "^0.12.2",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  }
+}

server/api.ts

@@ -0,0 +1,218 @@
+/**
+ * Optional HTTP API for watermark embedding/detection
+ *
+ * Serves the web UI and provides API endpoints for server-side processing.
+ * Used for HuggingFace Space deployment.
+ */
+
+import { createServer } from 'node:http';
+import { readFile, stat } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { writeFile, unlink } from 'node:fs/promises';
+import { probeVideo, readYuvFrames, createEncoder } from './ffmpeg-io.js';
+import { embedWatermark } from '../core/embedder.js';
+import { detectWatermark, detectWatermarkMultiFrame } from '../core/detector.js';
+import { getPreset } from '../core/presets.js';
+import type { PresetName } from '../core/types.js';
+
+const MIME_TYPES: Record<string, string> = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.woff2': 'font/woff2',
+};
+
+const PORT = parseInt(process.env.PORT || '7860', 10);
+const STATIC_DIR = process.env.STATIC_DIR || join(import.meta.dirname || '.', '../dist/web');
+
+async function serveStatic(url: string): Promise<{ data: Buffer; contentType: string } | null> {
+  const safePath = url.replace(/\.\./g, '').replace(/\/+/g, '/');
+  const filePath = join(STATIC_DIR, safePath === '/' ? 'index.html' : safePath);
+
+  try {
+    const s = await stat(filePath);
+    if (!s.isFile()) return null;
+    const data = await readFile(filePath);
+    const ext = extname(filePath);
+    return { data, contentType: MIME_TYPES[ext] || 'application/octet-stream' };
+  } catch {
+    return null;
+  }
+}
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+
+  // CORS + SharedArrayBuffer headers (required for ffmpeg.wasm)
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+  res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+
+  // API: Health check
+  if (url.pathname === '/api/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ status: 'ok' }));
+    return;
+  }
+
+  // API: Embed
+  if (url.pathname === '/api/embed' && req.method === 'POST') {
+    try {
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(chunk as Buffer);
+      const body = Buffer.concat(chunks);
+
+      // Parse multipart or raw JSON
+      const contentType = req.headers['content-type'] || '';
+
+      if (contentType.includes('application/json')) {
+        const { videoBase64, key, preset, payload } = JSON.parse(body.toString());
+
+        const videoBuffer = Buffer.from(videoBase64, 'base64');
+        const inputPath = join(tmpdir(), `ltmarx-in-${randomUUID()}.mp4`);
+        const outputPath = join(tmpdir(), `ltmarx-out-${randomUUID()}.mp4`);
+
+        await writeFile(inputPath, videoBuffer);
+
+        const config = getPreset((preset || 'moderate') as PresetName);
+        const payloadBytes = hexToBytes(payload || 'DEADBEEF');
+        const info = await probeVideo(inputPath);
+
+        const encoder = createEncoder(outputPath, info.width, info.height, info.fps);
+        const ySize = info.width * info.height;
+        const uvSize = (info.width / 2) * (info.height / 2);
+        let totalPsnr = 0;
+        let frameCount = 0;
+
+        for await (const frame of readYuvFrames(inputPath, info.width, info.height)) {
+          const result = embedWatermark(frame.y, info.width, info.height, payloadBytes, key, config);
+          totalPsnr += result.psnr;
+
+          const yuvFrame = Buffer.alloc(ySize + 2 * uvSize);
+          yuvFrame.set(result.yPlane, 0);
+          yuvFrame.set(frame.u, ySize);
+          yuvFrame.set(frame.v, ySize + uvSize);
+          encoder.stdin.write(yuvFrame);
+          frameCount++;
+        }
+
+        encoder.stdin.end();
+        await new Promise<void>((resolve) => encoder.process.on('close', () => resolve()));
+
+        const outputBuffer = await readFile(outputPath);
+
+        // Cleanup temp files
+        await unlink(inputPath).catch(() => {});
+        await unlink(outputPath).catch(() => {});
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          videoBase64: outputBuffer.toString('base64'),
+          frames: frameCount,
+          avgPsnr: totalPsnr / frameCount,
+        }));
+      } else {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Expected application/json content type' }));
+      }
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(e) }));
+    }
+    return;
+  }
+
+  // API: Detect
+  if (url.pathname === '/api/detect' && req.method === 'POST') {
+    try {
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(chunk as Buffer);
+      const body = JSON.parse(Buffer.concat(chunks).toString());
+
+      const { videoBase64, key, preset, frames: maxFrames } = body;
+      const videoBuffer = Buffer.from(videoBase64, 'base64');
+      const inputPath = join(tmpdir(), `ltmarx-det-${randomUUID()}.mp4`);
+
+      await writeFile(inputPath, videoBuffer);
+
+      const config = getPreset((preset || 'moderate') as PresetName);
+      const info = await probeVideo(inputPath);
+      const framesToRead = Math.min(maxFrames || 10, info.totalFrames);
+
+      const yPlanes: Uint8Array[] = [];
+      let count = 0;
+      for await (const frame of readYuvFrames(inputPath, info.width, info.height)) {
+        yPlanes.push(new Uint8Array(frame.y));
+        count++;
+        if (count >= framesToRead) break;
+      }
+
+      await unlink(inputPath).catch(() => {});
+
+      const result = detectWatermarkMultiFrame(yPlanes, info.width, info.height, key, config);
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        detected: result.detected,
+        payload: result.payload ? bytesToHex(result.payload) : null,
+        confidence: result.confidence,
+        tilesDecoded: result.tilesDecoded,
+        tilesTotal: result.tilesTotal,
+      }));
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: String(e) }));
+    }
+    return;
+  }
+
+  // Static file serving
+  const staticResult = await serveStatic(url.pathname);
+  if (staticResult) {
+    res.writeHead(200, { 'Content-Type': staticResult.contentType });
+    res.end(staticResult.data);
+    return;
+  }
+
+  // SPA fallback
+  const indexResult = await serveStatic('/');
+  if (indexResult) {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(indexResult.data);
+    return;
+  }
+
+  res.writeHead(404, { 'Content-Type': 'text/plain' });
+  res.end('Not Found');
+});
+
+server.listen(PORT, () => {
+  console.log(`LTMarx server listening on http://localhost:${PORT}`);
+});
+
+function hexToBytes(hex: string): Uint8Array {
+  const clean = hex.replace(/^0x/, '');
+  const padded = clean.length % 2 ? '0' + clean : clean;
+  const bytes = new Uint8Array(padded.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase();
+}

server/cli.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+
+/**
+ * LTMarx CLI — Video watermark embedding and detection
+ *
+ * Usage:
+ *   ltmarx embed -i input.mp4 -o output.mp4 --key SECRET --preset moderate
+ *   ltmarx detect -i video.mp4 --key SECRET --preset moderate
+ */
+
+import { parseArgs } from 'node:util';
+import { probeVideo, readYuvFrames, createEncoder } from './ffmpeg-io.js';
+import { embedWatermark } from '../core/embedder.js';
+import { detectWatermark, detectWatermarkMultiFrame } from '../core/detector.js';
+import { getPreset, PRESET_DESCRIPTIONS } from '../core/presets.js';
+import type { PresetName } from '../core/types.js';
+
+function usage() {
+  console.log(`
+LTMarx — Video Watermarking System
+
+Commands:
+  embed     Embed a watermark into a video
+  detect    Detect and extract a watermark from a video
+  presets   List available presets
+
+Usage:
+  ltmarx embed -i input.mp4 -o output.mp4 --key SECRET --preset moderate --payload DEADBEEF
+  ltmarx detect -i video.mp4 --key SECRET --preset moderate [--frames N]
+  ltmarx presets
+
+Options:
+  -i, --input     Input video file
+  -o, --output    Output video file (embed only)
+  --key           Secret key for watermark
+  --preset        Preset name: light, moderate, strong, fortress
+  --payload       32-bit payload as hex string (embed only, default: DEADBEEF)
+  --frames        Number of frames to analyze (detect only, default: 10)
+  --crf           Output CRF quality (embed only, default: 18)
+`);
+  process.exit(1);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (!command || command === '--help' || command === '-h') usage();
+
+  if (command === 'presets') {
+    console.log('\nAvailable presets:\n');
+    for (const [name, desc] of Object.entries(PRESET_DESCRIPTIONS)) {
+      console.log(`  ${name.padEnd(12)} ${desc}`);
+    }
+    console.log();
+    process.exit(0);
+  }
+
+  const { values } = parseArgs({
+    args: args.slice(1),
+    options: {
+      input: { type: 'string', short: 'i' },
+      output: { type: 'string', short: 'o' },
+      key: { type: 'string' },
+      preset: { type: 'string' },
+      payload: { type: 'string' },
+      frames: { type: 'string' },
+      crf: { type: 'string' },
+    },
+  });
+
+  const input = values.input;
+  const key = values.key;
+  const presetName = (values.preset || 'moderate') as PresetName;
+
+  if (!input) { console.error('Error: --input is required'); process.exit(1); }
+  if (!key) { console.error('Error: --key is required'); process.exit(1); }
+
+  const config = getPreset(presetName);
+
+  if (command === 'embed') {
+    const output = values.output;
+    if (!output) { console.error('Error: --output is required for embed'); process.exit(1); }
+
+    const payloadHex = values.payload || 'DEADBEEF';
+    const payload = hexToBytes(payloadHex);
+    const crf = parseInt(values.crf || '18', 10);
+
+    console.log(`Embedding watermark...`);
+    console.log(`  Input:   ${input}`);
+    console.log(`  Output:  ${output}`);
+    console.log(`  Preset:  ${presetName}`);
+    console.log(`  Payload: ${payloadHex}`);
+    console.log(`  CRF:     ${crf}`);
+
+    const info = await probeVideo(input);
+    console.log(`  Video:   ${info.width}x${info.height} @ ${info.fps.toFixed(2)} fps, ${info.totalFrames} frames`);
+
+    const encoder = createEncoder(output, info.width, info.height, info.fps, crf);
+    let frameCount = 0;
+    let totalPsnr = 0;
+
+    const ySize = info.width * info.height;
+    const uvSize = (info.width / 2) * (info.height / 2);
+
+    for await (const frame of readYuvFrames(input, info.width, info.height)) {
+      const result = embedWatermark(frame.y, info.width, info.height, payload, key, config);
+      totalPsnr += result.psnr;
+
+      // Write YUV420p frame: watermarked Y + original U + V
+      const yuvFrame = Buffer.alloc(ySize + 2 * uvSize);
+      yuvFrame.set(result.yPlane, 0);
+      yuvFrame.set(frame.u, ySize);
+      yuvFrame.set(frame.v, ySize + uvSize);
+
+      encoder.stdin.write(yuvFrame);
+      frameCount++;
+
+      if (frameCount % 30 === 0) {
+        process.stdout.write(`\r  Progress: ${frameCount} frames (PSNR: ${(totalPsnr / frameCount).toFixed(1)} dB)`);
+      }
+    }
+
+    encoder.stdin.end();
+    await new Promise<void>((resolve) => encoder.process.on('close', () => resolve()));
+
+    console.log(`\r  Complete: ${frameCount} frames, avg PSNR: ${(totalPsnr / frameCount).toFixed(1)} dB`);
+    console.log(`  Output saved to: ${output}`);
+
+  } else if (command === 'detect') {
+    const maxFrames = parseInt(values.frames || '10', 10);
+
+    console.log(`Detecting watermark...`);
+    console.log(`  Input:   ${input}`);
+    console.log(`  Preset:  ${presetName}`);
+    console.log(`  Frames:  ${maxFrames}`);
+
+    const info = await probeVideo(input);
+    console.log(`  Video:   ${info.width}x${info.height} @ ${info.fps.toFixed(2)} fps`);
+
+    const yPlanes: Uint8Array[] = [];
+    let frameCount = 0;
+
+    for await (const frame of readYuvFrames(input, info.width, info.height)) {
+      yPlanes.push(new Uint8Array(frame.y));
+      frameCount++;
+      if (frameCount >= maxFrames) break;
+      process.stdout.write(`\r  Reading frame ${frameCount}/${maxFrames}...`);
+    }
+
+    console.log(`\r  Analyzing ${yPlanes.length} frames...`);
+
+    // Try multi-frame detection first
+    if (yPlanes.length > 1) {
+      const result = detectWatermarkMultiFrame(yPlanes, info.width, info.height, key, config);
+      if (result.detected) {
+        console.log(`\n  WATERMARK DETECTED (multi-frame)`);
+        console.log(`  Payload:    ${bytesToHex(result.payload!)}`);
+        console.log(`  Confidence: ${(result.confidence * 100).toFixed(1)}%`);
+        console.log(`  Tiles:      ${result.tilesDecoded}/${result.tilesTotal}`);
+        process.exit(0);
+      }
+    }
+
+    // Try single-frame detection
+    for (let i = 0; i < yPlanes.length; i++) {
+      const result = detectWatermark(yPlanes[i], info.width, info.height, key, config);
+      if (result.detected) {
+        console.log(`\n  WATERMARK DETECTED (frame ${i + 1})`);
+        console.log(`  Payload:    ${bytesToHex(result.payload!)}`);
+        console.log(`  Confidence: ${(result.confidence * 100).toFixed(1)}%`);
+        console.log(`  Tiles:      ${result.tilesDecoded}/${result.tilesTotal}`);
+        process.exit(0);
+      }
+    }
+
+    console.log(`\n  No watermark detected.`);
+    process.exit(1);
+
+  } else {
+    console.error(`Unknown command: ${command}`);
+    usage();
+  }
+}
+
+function hexToBytes(hex: string): Uint8Array {
+  const clean = hex.replace(/^0x/, '');
+  const padded = clean.length % 2 ? '0' + clean : clean;
+  const bytes = new Uint8Array(padded.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(padded.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase();
+}
+
+main().catch((e) => {
+  console.error('Error:', e.message || e);
+  process.exit(1);
+});

server/ffmpeg-io.ts

@@ -0,0 +1,163 @@
+/**
+ * FFmpeg-based video I/O for server-side watermark processing
+ *
+ * Spawns FFmpeg subprocesses to decode/encode raw YUV420p frames.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+
+/** Video metadata */
+export interface VideoInfo {
+  width: number;
+  height: number;
+  fps: number;
+  duration: number;
+  totalFrames: number;
+}
+
+/**
+ * Probe video file for metadata using ffprobe
+ */
+export async function probeVideo(inputPath: string): Promise<VideoInfo> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ffprobe', [
+      '-v', 'quiet',
+      '-print_format', 'json',
+      '-show_streams',
+      '-show_format',
+      inputPath,
+    ]);
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d: Buffer) => (stdout += d.toString()));
+    proc.stderr.on('data', (d: Buffer) => (stderr += d.toString()));
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffprobe failed (${code}): ${stderr}`));
+        return;
+      }
+      try {
+        const info = JSON.parse(stdout);
+        const videoStream = info.streams?.find((s: { codec_type: string }) => s.codec_type === 'video');
+        if (!videoStream) throw new Error('No video stream found');
+
+        const [num, den] = (videoStream.r_frame_rate || '30/1').split('/').map(Number);
+        const fps = den ? num / den : 30;
+        const duration = parseFloat(info.format?.duration || videoStream.duration || '0');
+        const totalFrames = Math.ceil(fps * duration);
+
+        resolve({
+          width: videoStream.width,
+          height: videoStream.height,
+          fps,
+          duration,
+          totalFrames,
+        });
+      } catch (e) {
+        reject(new Error(`Failed to parse ffprobe output: ${e}`));
+      }
+    });
+  });
+}
+
+/**
+ * Frame reader: decodes a video file to raw Y planes
+ * Yields one Y plane (Uint8Array of width*height) per frame
+ */
+export async function* readYPlanes(
+  inputPath: string,
+  width: number,
+  height: number
+): AsyncGenerator<Uint8Array> {
+  const frameSize = width * height; // Y plane only
+  const yuvFrameSize = frameSize * 3 / 2; // YUV420p: Y + U/4 + V/4
+
+  const proc = spawn('ffmpeg', [
+    '-i', inputPath,
+    '-f', 'rawvideo',
+    '-pix_fmt', 'yuv420p',
+    '-v', 'error',
+    'pipe:1',
+  ], { stdio: ['ignore', 'pipe', 'pipe'] });
+
+  let buffer = Buffer.alloc(0);
+
+  for await (const chunk of proc.stdout as AsyncIterable<Buffer>) {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (buffer.length >= yuvFrameSize) {
+      // Extract Y plane (first width*height bytes of YUV420p frame)
+      const yPlane = new Uint8Array(buffer.subarray(0, frameSize));
+      yield yPlane;
+      buffer = buffer.subarray(yuvFrameSize);
+    }
+  }
+}
+
+/**
+ * Create a write pipe to FFmpeg for encoding watermarked frames
+ * Returns a writable stream that accepts YUV420p frame data
+ */
+export function createEncoder(
+  outputPath: string,
+  width: number,
+  height: number,
+  fps: number,
+  crf: number = 18
+): { stdin: Writable; process: ChildProcess } {
+  const proc = spawn('ffmpeg', [
+    '-y',
+    '-f', 'rawvideo',
+    '-pix_fmt', 'yuv420p',
+    '-s', `${width}x${height}`,
+    '-r', String(fps),
+    '-i', 'pipe:0',
+    '-c:v', 'libx264',
+    '-crf', String(crf),
+    '-preset', 'medium',
+    '-pix_fmt', 'yuv420p',
+    '-v', 'error',
+    outputPath,
+  ], { stdio: ['pipe', 'ignore', 'pipe'] });
+
+  return { stdin: proc.stdin, process: proc };
+}
+
+/**
+ * Read all YUV420p frames from video and provide full frame buffers
+ * (Y, U, V planes) for pass-through of chroma channels
+ */
+export async function* readYuvFrames(
+  inputPath: string,
+  width: number,
+  height: number
+): AsyncGenerator<{ y: Uint8Array; u: Uint8Array; v: Uint8Array }> {
+  const ySize = width * height;
+  const uvSize = (width / 2) * (height / 2);
+  const frameSize = ySize + 2 * uvSize;
+
+  const proc = spawn('ffmpeg', [
+    '-i', inputPath,
+    '-f', 'rawvideo',
+    '-pix_fmt', 'yuv420p',
+    '-v', 'error',
+    'pipe:1',
+  ], { stdio: ['ignore', 'pipe', 'pipe'] });
+
+  let buffer = Buffer.alloc(0);
+
+  for await (const chunk of proc.stdout as AsyncIterable<Buffer>) {
+    buffer = Buffer.concat([buffer, chunk]);
+
+    while (buffer.length >= frameSize) {
+      const y = new Uint8Array(buffer.subarray(0, ySize));
+      const u = new Uint8Array(buffer.subarray(ySize, ySize + uvSize));
+      const v = new Uint8Array(buffer.subarray(ySize + uvSize, frameSize));
+      yield { y, u, v };
+      buffer = buffer.subarray(frameSize);
+    }
+  }
+}

tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@core/*": ["./core/*"]
+    }
+  },
+  "include": ["core/**/*.ts", "web/src/**/*.ts", "web/src/**/*.tsx", "server/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

tsconfig.server.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@core/*": ["./core/*"]
+    }
+  },
+  "include": ["core/**/*.ts", "server/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

vite.config.ts

@@ -0,0 +1,31 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import { resolve } from 'path';
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  root: 'web',
+  resolve: {
+    alias: {
+      '@core': resolve(__dirname, 'core'),
+    },
+  },
+  build: {
+    outDir: '../dist/web',
+    emptyOutDir: true,
+  },
+  worker: {
+    format: 'es',
+  },
+  server: {
+    headers: {
+      // Required for ffmpeg.wasm SharedArrayBuffer support
+      'Cross-Origin-Opener-Policy': 'same-origin',
+      'Cross-Origin-Embedder-Policy': 'require-corp',
+    },
+  },
+  optimizeDeps: {
+    exclude: ['@ffmpeg/ffmpeg', '@ffmpeg/util'],
+  },
+});

web/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>LTMarX — Video Watermarking</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>&#x1f3ac;</text></svg>" />
+  </head>
+  <body class="bg-zinc-950 text-zinc-100 antialiased">
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

web/src/App.tsx

@@ -0,0 +1,88 @@
+import { useState } from 'react';
+import EmbedPanel from './components/EmbedPanel.js';
+import DetectPanel from './components/DetectPanel.js';
+import ApiDocs from './components/ApiDocs.js';
+
+export default function App() {
+  const [tab, setTab] = useState<'embed' | 'detect' | 'api'>('embed');
+
+  return (
+    <div className="min-h-screen bg-zinc-950">
+      <header className="sticky top-0 z-10 border-b border-zinc-800/50 bg-zinc-950/80 px-6 py-4 backdrop-blur-xl">
+        <div className="mx-auto flex max-w-2xl items-center justify-between">
+          <div className="flex items-center gap-3">
+            <div className="flex h-8 w-8 items-center justify-center rounded-lg bg-gradient-to-br from-blue-600 to-violet-600 shadow-lg shadow-blue-600/20">
+              <svg className="h-4 w-4 text-white" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                <path strokeLinecap="round" strokeLinejoin="round" d="M15 10l4.553-2.276A1 1 0 0121 8.618v6.764a1 1 0 01-1.447.894L15 14M5 18h8a2 2 0 002-2V8a2 2 0 00-2-2H5a2 2 0 00-2 2v8a2 2 0 002 2z" />
+              </svg>
+            </div>
+            <div>
+              <h1 className="text-lg font-bold tracking-tight text-zinc-100">
+                LTMar<span className="text-blue-400">X</span>
+              </h1>
+              <p className="text-[10px] text-zinc-600">The watermark bits your generated video didn't even know it needs</p>
+            </div>
+          </div>
+          <nav className="flex gap-1 rounded-xl bg-zinc-900/80 p-1 ring-1 ring-zinc-800/50">
+            <button
+              onClick={() => setTab('embed')}
+              className={`rounded-lg px-4 py-1.5 text-sm font-medium transition-all ${
+                tab === 'embed'
+                  ? 'bg-zinc-800 text-zinc-100 shadow-sm'
+                  : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              🎨 Embed
+            </button>
+            <button
+              onClick={() => setTab('detect')}
+              className={`rounded-lg px-4 py-1.5 text-sm font-medium transition-all ${
+                tab === 'detect'
+                  ? 'bg-zinc-800 text-zinc-100 shadow-sm'
+                  : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              🔍 Detect
+            </button>
+            <button
+              onClick={() => setTab('api')}
+              className={`rounded-lg px-4 py-1.5 text-sm font-medium transition-all ${
+                tab === 'api'
+                  ? 'bg-zinc-800 text-zinc-100 shadow-sm'
+                  : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              {'{}'} API
+            </button>
+          </nav>
+        </div>
+      </header>
+
+      <main className="mx-auto max-w-2xl px-6 py-10">
+        <div className="mb-8">
+          <h2 className="text-2xl font-bold tracking-tight text-zinc-100">
+            {tab === 'embed' ? '🎬 Embed Watermark' : tab === 'detect' ? '🔎 Detect Watermark' : '📖 API Reference'}
+          </h2>
+          <p className="mt-1 text-sm text-zinc-500">
+            {tab === 'embed'
+              ? 'Embed an imperceptible 32-bit payload into your video.'
+              : tab === 'detect'
+              ? 'Analyze a video to detect and extract embedded watermarks.'
+              : 'Integrate LTMarX into your application.'}
+          </p>
+        </div>
+
+        {tab === 'embed' ? <EmbedPanel /> : tab === 'detect' ? <DetectPanel /> : <ApiDocs />}
+      </main>
+
+      <footer className="border-t border-zinc-800/30 px-6 py-6">
+        <div className="mx-auto max-w-2xl">
+          <p className="text-center text-[11px] text-zinc-700">
+            LTMar<span className="text-zinc-600">X</span> — DWT/DCT watermarking with DM-QIM and BCH error correction.
+            All processing happens in your browser.
+          </p>
+        </div>
+      </footer>
+    </div>
+  );
+}

web/src/components/ApiDocs.tsx

@@ -0,0 +1,277 @@
+import { useState } from 'react';
+
+interface CodeBlockProps {
+  lang: string;
+  children: string;
+}
+
+function CodeBlock({ lang, children }: CodeBlockProps) {
+  const [copied, setCopied] = useState(false);
+  const copy = () => {
+    navigator.clipboard.writeText(children.trim());
+    setCopied(true);
+    setTimeout(() => setCopied(false), 1500);
+  };
+  return (
+    <div className="group relative">
+      <div className="flex items-center justify-between rounded-t-lg bg-zinc-800/80 px-3 py-1.5">
+        <span className="text-[10px] font-medium uppercase tracking-wider text-zinc-500">{lang}</span>
+        <button
+          onClick={copy}
+          className="text-[10px] text-zinc-500 transition-colors hover:text-zinc-300"
+        >
+          {copied ? 'Copied!' : 'Copy'}
+        </button>
+      </div>
+      <pre className="overflow-x-auto rounded-b-lg bg-zinc-900/80 p-3 text-xs leading-relaxed text-zinc-300 ring-1 ring-zinc-800/50">
+        <code>{children.trim()}</code>
+      </pre>
+    </div>
+  );
+}
+
+function Section({ title, children }: { title: string; children: React.ReactNode }) {
+  return (
+    <div className="space-y-3">
+      <h3 className="text-sm font-semibold text-zinc-200">{title}</h3>
+      {children}
+    </div>
+  );
+}
+
+function Endpoint({ method, path, desc }: { method: string; path: string; desc: string }) {
+  const color = method === 'POST' ? 'text-amber-400 bg-amber-400/10' : 'text-emerald-400 bg-emerald-400/10';
+  return (
+    <div className="flex items-start gap-2">
+      <span className={`mt-0.5 shrink-0 rounded px-1.5 py-0.5 text-[10px] font-bold ${color}`}>{method}</span>
+      <div>
+        <code className="text-xs font-medium text-zinc-200">{path}</code>
+        <p className="mt-0.5 text-xs text-zinc-500">{desc}</p>
+      </div>
+    </div>
+  );
+}
+
+function ParamTable({ params }: { params: { name: string; type: string; desc: string; required?: boolean }[] }) {
+  return (
+    <div className="overflow-hidden rounded-lg ring-1 ring-zinc-800/50">
+      <table className="w-full text-xs">
+        <thead>
+          <tr className="border-b border-zinc-800/50 bg-zinc-900/50">
+            <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Parameter</th>
+            <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Type</th>
+            <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Description</th>
+          </tr>
+        </thead>
+        <tbody>
+          {params.map((p) => (
+            <tr key={p.name} className="border-b border-zinc-800/30 last:border-0">
+              <td className="px-3 py-1.5">
+                <code className="text-zinc-200">{p.name}</code>
+                {p.required && <span className="ml-1 text-[9px] text-red-400">*</span>}
+              </td>
+              <td className="px-3 py-1.5 text-zinc-500">{p.type}</td>
+              <td className="px-3 py-1.5 text-zinc-400">{p.desc}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}
+
+export default function ApiDocs() {
+  return (
+    <div className="space-y-8">
+      {/* Core Library */}
+      <Section title="Core Library (TypeScript)">
+        <p className="text-xs text-zinc-400">
+          The core engine is isomorphic — same code runs in the browser and on Node.js.
+          It operates on raw Y-plane (luminance) buffers with no platform dependencies.
+        </p>
+
+        <div className="space-y-4">
+          <div className="space-y-2">
+            <h4 className="text-xs font-medium text-zinc-300">Embed a watermark</h4>
+            <CodeBlock lang="typescript">{`
+import { embedWatermark } from '@core/embedder';
+import { getPreset } from '@core/presets';
+
+const config = getPreset('moderate');
+const payload = new Uint8Array([0xDE, 0xAD, 0xBE, 0xEF]);
+
+const result = embedWatermark(yPlane, width, height, payload, secretKey, config);
+// result.yPlane  → Uint8Array (watermarked luminance)
+// result.psnr    → number (quality in dB, higher = less visible)
+            `}</CodeBlock>
+          </div>
+
+          <div className="space-y-2">
+            <h4 className="text-xs font-medium text-zinc-300">Detect a watermark</h4>
+            <CodeBlock lang="typescript">{`
+import { detectWatermarkMultiFrame } from '@core/detector';
+import { getPreset } from '@core/presets';
+
+const config = getPreset('moderate');
+const result = detectWatermarkMultiFrame(yPlanes, width, height, secretKey, config);
+// result.detected    → boolean
+// result.payload     → Uint8Array | null (the 4-byte payload)
+// result.confidence  → number (0–1)
+// result.tilesDecoded → number
+            `}</CodeBlock>
+          </div>
+
+          <div className="space-y-2">
+            <h4 className="text-xs font-medium text-zinc-300">Auto-detect (tries all presets)</h4>
+            <CodeBlock lang="typescript">{`
+import { autoDetectMultiFrame } from '@core/detector';
+
+const result = autoDetectMultiFrame(yPlanes, width, height, secretKey);
+// result.presetUsed → 'light' | 'moderate' | 'strong' | 'fortress' | null
+            `}</CodeBlock>
+          </div>
+        </div>
+      </Section>
+
+      {/* HTTP API */}
+      <Section title="HTTP API">
+        <p className="text-xs text-zinc-400">
+          Available when running the server via <code className="text-zinc-300">tsx server/api.ts</code> or Docker.
+        </p>
+
+        <div className="space-y-4">
+          <div className="space-y-2">
+            <Endpoint method="POST" path="/api/embed" desc="Embed a watermark into a video" />
+            <ParamTable params={[
+              { name: 'videoBase64', type: 'string', desc: 'Base64-encoded video file', required: true },
+              { name: 'key', type: 'string', desc: 'Secret key for embedding', required: true },
+              { name: 'preset', type: 'string', desc: 'light | moderate | strong | fortress', required: true },
+              { name: 'payload', type: 'string', desc: 'Hex string, up to 8 chars (32 bits)', required: true },
+            ]} />
+            <CodeBlock lang="bash">{`
+curl -X POST http://localhost:7860/api/embed \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "videoBase64": "'$(base64 -i input.mp4)'",
+    "key": "my-secret",
+    "preset": "moderate",
+    "payload": "DEADBEEF"
+  }'
+            `}</CodeBlock>
+          </div>
+
+          <div className="space-y-2">
+            <Endpoint method="POST" path="/api/detect" desc="Detect and extract a watermark from a video" />
+            <ParamTable params={[
+              { name: 'videoBase64', type: 'string', desc: 'Base64-encoded video file', required: true },
+              { name: 'key', type: 'string', desc: 'Secret key used during embedding', required: true },
+              { name: 'preset', type: 'string', desc: 'Preset to try (omit to try all)', required: false },
+              { name: 'frames', type: 'number', desc: 'Max frames to analyze (default: 10)', required: false },
+            ]} />
+            <CodeBlock lang="json">{`
+{
+  "detected": true,
+  "payload": "DEADBEEF",
+  "confidence": 0.97,
+  "preset": "moderate",
+  "tilesDecoded": 12,
+  "tilesTotal": 16
+}
+            `}</CodeBlock>
+          </div>
+
+          <Endpoint method="GET" path="/api/health" desc="Health check — returns { status: 'ok' }" />
+        </div>
+      </Section>
+
+      {/* CLI */}
+      <Section title="CLI">
+        <p className="text-xs text-zinc-400">
+          Requires Node.js and FFmpeg installed locally.
+        </p>
+
+        <div className="space-y-2">
+          <CodeBlock lang="bash">{`
+# Embed a watermark
+npx tsx server/cli.ts embed \\
+  -i input.mp4 -o output.mp4 \\
+  --key SECRET --preset moderate --payload DEADBEEF
+
+# Detect a watermark (auto-tries all presets)
+npx tsx server/cli.ts detect -i video.mp4 --key SECRET
+
+# List available presets
+npx tsx server/cli.ts presets
+          `}</CodeBlock>
+        </div>
+      </Section>
+
+      {/* Presets reference */}
+      <Section title="Presets">
+        <div className="overflow-hidden rounded-lg ring-1 ring-zinc-800/50">
+          <table className="w-full text-xs">
+            <thead>
+              <tr className="border-b border-zinc-800/50 bg-zinc-900/50">
+                <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Preset</th>
+                <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Delta</th>
+                <th className="px-3 py-1.5 text-left font-medium text-zinc-400">BCH</th>
+                <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Masking</th>
+                <th className="px-3 py-1.5 text-left font-medium text-zinc-400">Use case</th>
+              </tr>
+            </thead>
+            <tbody>
+              {[
+                { name: 'Light', delta: 50, bch: '(63,36,5)', mask: 'No', use: 'Near-invisible, mild compression' },
+                { name: 'Moderate', delta: 80, bch: '(63,36,5)', mask: 'Yes', use: 'Balanced with perceptual masking' },
+                { name: 'Strong', delta: 110, bch: '(63,36,5)', mask: 'Yes', use: 'More frequencies, handles rescaling' },
+                { name: 'Fortress', delta: 150, bch: '(63,36,5)', mask: 'Yes', use: 'Maximum robustness' },
+              ].map((p) => (
+                <tr key={p.name} className="border-b border-zinc-800/30 last:border-0">
+                  <td className="px-3 py-1.5 font-medium text-zinc-200">{p.name}</td>
+                  <td className="px-3 py-1.5 tabular-nums text-zinc-400">{p.delta}</td>
+                  <td className="px-3 py-1.5 font-mono text-zinc-400">{p.bch}</td>
+                  <td className="px-3 py-1.5 text-zinc-400">{p.mask}</td>
+                  <td className="px-3 py-1.5 text-zinc-400">{p.use}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </Section>
+
+      {/* How it works */}
+      <Section title="How It Works">
+        <div className="space-y-3 text-xs text-zinc-400">
+          <div className="rounded-lg bg-zinc-900/50 p-3 ring-1 ring-zinc-800/50">
+            <p className="mb-2 font-medium text-zinc-300">Embedding pipeline</p>
+            <code className="block leading-relaxed text-zinc-400">
+              Y plane → 2-level Haar DWT → HL subband → tile grid →<br />
+              per tile: 8x8 DCT → select mid-freq coefficients →<br />
+              DM-QIM embed coded bits → inverse DCT → inverse DWT
+            </code>
+          </div>
+          <div className="rounded-lg bg-zinc-900/50 p-3 ring-1 ring-zinc-800/50">
+            <p className="mb-2 font-medium text-zinc-300">Payload encoding</p>
+            <code className="block leading-relaxed text-zinc-400">
+              32-bit payload → CRC append → BCH encode → keyed interleave → map to coefficients
+            </code>
+          </div>
+          <div className="rounded-lg bg-zinc-900/50 p-3 ring-1 ring-zinc-800/50">
+            <p className="mb-2 font-medium text-zinc-300">Detection</p>
+            <code className="block leading-relaxed text-zinc-400">
+              Y plane → DWT → HL subband → tile grid →<br />
+              per tile: DCT → DM-QIM soft extract →<br />
+              soft-combine across tiles + frames → BCH decode → CRC verify
+            </code>
+          </div>
+          <p>
+            The watermark is embedded exclusively in the <strong className="text-zinc-300">luminance (Y) channel</strong> within
+            the DWT-domain DCT coefficients. This makes it invisible to the human eye while surviving
+            lossy compression, rescaling, and color adjustments. Each tile carries a complete copy of
+            the payload for redundancy — more tiles means better detection under degradation.
+          </p>
+        </div>
+      </Section>
+    </div>
+  );
+}

web/src/components/ComparisonView.tsx

@@ -0,0 +1,197 @@
+import { useRef, useEffect, useState } from 'react';
+
+interface ComparisonViewProps {
+  originalFrames: ImageData[];
+  watermarkedFrames: ImageData[];
+  width: number;
+  height: number;
+  fps: number;
+}
+
+export default function ComparisonView({
+  originalFrames,
+  watermarkedFrames,
+  width,
+  height,
+  fps,
+}: ComparisonViewProps) {
+  const [mode, setMode] = useState<'side-by-side' | 'difference'>('side-by-side');
+  const [amplify, setAmplify] = useState(1);
+  const [playing, setPlaying] = useState(false);
+  const [currentFrame, setCurrentFrame] = useState(0);
+  const diffCanvasRef = useRef<HTMLCanvasElement>(null);
+  const origCanvasRef = useRef<HTMLCanvasElement>(null);
+  const wmCanvasRef = useRef<HTMLCanvasElement>(null);
+  const animRef = useRef<number>(0);
+  const lastFrameTime = useRef(0);
+
+  const totalFrames = originalFrames.length;
+
+  // Render side-by-side canvases for current frame
+  useEffect(() => {
+    if (mode !== 'side-by-side') return;
+    const origCtx = origCanvasRef.current?.getContext('2d');
+    const wmCtx = wmCanvasRef.current?.getContext('2d');
+    if (origCtx && originalFrames[currentFrame]) {
+      origCtx.putImageData(originalFrames[currentFrame], 0, 0);
+    }
+    if (wmCtx && watermarkedFrames[currentFrame]) {
+      wmCtx.putImageData(watermarkedFrames[currentFrame], 0, 0);
+    }
+  }, [originalFrames, watermarkedFrames, mode, currentFrame]);
+
+  // Render diff frame
+  useEffect(() => {
+    if (mode !== 'difference') return;
+    const ctx = diffCanvasRef.current?.getContext('2d');
+    if (!ctx || !originalFrames[currentFrame] || !watermarkedFrames[currentFrame]) return;
+
+    const orig = originalFrames[currentFrame];
+    const wm = watermarkedFrames[currentFrame];
+    const diff = new ImageData(width, height);
+
+    for (let i = 0; i < orig.data.length; i += 4) {
+      const dr = Math.abs(orig.data[i] - wm.data[i]);
+      const dg = Math.abs(orig.data[i + 1] - wm.data[i + 1]);
+      const db = Math.abs(orig.data[i + 2] - wm.data[i + 2]);
+      const d = Math.max(dr, dg, db);
+      const amplified = Math.min(255, d * amplify);
+      diff.data[i] = amplified;
+      diff.data[i + 1] = 0;
+      diff.data[i + 2] = 255 - amplified;
+      diff.data[i + 3] = 255;
+    }
+    ctx.putImageData(diff, 0, 0);
+  }, [originalFrames, watermarkedFrames, mode, amplify, currentFrame, width, height]);
+
+  // Playback loop
+  useEffect(() => {
+    if (!playing) return;
+    const interval = 1000 / Math.min(fps, 5);
+
+    const step = (time: number) => {
+      if (time - lastFrameTime.current >= interval) {
+        setCurrentFrame((f) => (f + 1) % totalFrames);
+        lastFrameTime.current = time;
+      }
+      animRef.current = requestAnimationFrame(step);
+    };
+    animRef.current = requestAnimationFrame(step);
+
+    return () => cancelAnimationFrame(animRef.current);
+  }, [playing, fps, totalFrames]);
+
+  const aspect = `${width} / ${height}`;
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <div className="flex gap-1 rounded-md bg-zinc-800/50 p-0.5">
+            <button
+              onClick={() => setMode('side-by-side')}
+              className={`rounded-md px-3 py-1 text-xs font-medium transition-colors ${
+                mode === 'side-by-side' ? 'bg-zinc-700 text-zinc-100' : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              Side by Side
+            </button>
+            <button
+              onClick={() => setMode('difference')}
+              className={`rounded-md px-3 py-1 text-xs font-medium transition-colors ${
+                mode === 'difference' ? 'bg-zinc-700 text-zinc-100' : 'text-zinc-400 hover:text-zinc-200'
+              }`}
+            >
+              Difference
+            </button>
+          </div>
+
+          <button
+            onClick={() => setPlaying(!playing)}
+            className="rounded-md bg-zinc-800/50 px-2.5 py-1 text-xs text-zinc-400 hover:text-zinc-200 transition-colors"
+          >
+            {playing ? 'Pause' : 'Play'}
+          </button>
+        </div>
+
+        <div className="flex items-center gap-3">
+          {mode === 'difference' && (
+            <div className="flex items-center gap-2">
+              <span className="text-[10px] text-zinc-500">Amplify</span>
+              <input
+                type="range"
+                min={1}
+                max={10}
+                value={amplify}
+                onChange={(e) => setAmplify(parseInt(e.target.value))}
+                className="h-1 w-20 appearance-none rounded-full bg-zinc-700 accent-violet-500
+                  [&::-webkit-slider-thumb]:appearance-none
+                  [&::-webkit-slider-thumb]:w-3
+                  [&::-webkit-slider-thumb]:h-3
+                  [&::-webkit-slider-thumb]:rounded-full
+                  [&::-webkit-slider-thumb]:bg-violet-500"
+              />
+              <span className="text-[10px] tabular-nums text-zinc-500">{amplify}x</span>
+            </div>
+          )}
+          <span className="text-[10px] tabular-nums text-zinc-600">
+            {currentFrame + 1}/{totalFrames}
+          </span>
+        </div>
+      </div>
+
+      {mode === 'side-by-side' ? (
+        <div className="grid grid-cols-2 gap-2">
+          <div className="space-y-1">
+            <p className="text-[10px] uppercase tracking-wider text-zinc-600">Original</p>
+            <canvas
+              ref={origCanvasRef}
+              width={width}
+              height={height}
+              className="w-full rounded-lg border border-zinc-800"
+              style={{ aspectRatio: aspect }}
+            />
+          </div>
+          <div className="space-y-1">
+            <p className="text-[10px] uppercase tracking-wider text-zinc-600">Watermarked</p>
+            <canvas
+              ref={wmCanvasRef}
+              width={width}
+              height={height}
+              className="w-full rounded-lg border border-zinc-800"
+              style={{ aspectRatio: aspect }}
+            />
+          </div>
+        </div>
+      ) : (
+        <div className="space-y-1">
+          <p className="text-[10px] uppercase tracking-wider text-zinc-600">
+            Pixel Difference (amplified {amplify}x)
+          </p>
+          <canvas
+            ref={diffCanvasRef}
+            width={width}
+            height={height}
+            className="w-full rounded-lg border border-zinc-800"
+            style={{ aspectRatio: aspect }}
+          />
+        </div>
+      )}
+
+      {/* Frame scrubber */}
+      <input
+        type="range"
+        min={0}
+        max={totalFrames - 1}
+        value={currentFrame}
+        onChange={(e) => { setCurrentFrame(parseInt(e.target.value)); setPlaying(false); }}
+        className="w-full h-1 appearance-none rounded-full bg-zinc-700 accent-blue-500
+          [&::-webkit-slider-thumb]:appearance-none
+          [&::-webkit-slider-thumb]:w-3
+          [&::-webkit-slider-thumb]:h-3
+          [&::-webkit-slider-thumb]:rounded-full
+          [&::-webkit-slider-thumb]:bg-blue-500"
+      />
+    </div>
+  );
+}

web/src/components/DetectPanel.tsx

@@ -0,0 +1,155 @@
+import { useState, useRef, useCallback } from 'react';
+import type { DetectionResult } from '@core/types.js';
+import { autoDetectMultiFrame, type AutoDetectResult } from '@core/detector.js';
+import { extractFrames, rgbaToY } from '../lib/video-io.js';
+import ResultCard from './ResultCard.js';
+
+export default function DetectPanel() {
+  const [videoUrl, setVideoUrl] = useState<string | null>(null);
+  const [videoName, setVideoName] = useState('');
+  const [key, setKey] = useState('');
+  const [maxFrames, setMaxFrames] = useState(10);
+  const [processing, setProcessing] = useState(false);
+  const [progress, setProgress] = useState({ phase: '', current: 0, total: 0 });
+  const [result, setResult] = useState<AutoDetectResult | null>(null);
+  const fileRef = useRef<HTMLInputElement>(null);
+
+  const handleFile = useCallback((file: File) => {
+    const url = URL.createObjectURL(file);
+    setVideoUrl(url);
+    setVideoName(file.name);
+    setResult(null);
+  }, []);
+
+  const handleDrop = useCallback(
+    (e: React.DragEvent) => {
+      e.preventDefault();
+      const file = e.dataTransfer.files[0];
+      if (file?.type.startsWith('video/')) handleFile(file);
+    },
+    [handleFile]
+  );
+
+  const handleDetect = async () => {
+    if (!videoUrl || !key) return;
+    setProcessing(true);
+    setResult(null);
+
+    try {
+      setProgress({ phase: 'Extracting frames', current: 0, total: 0 });
+      const { frames, width, height } = await extractFrames(videoUrl, maxFrames, (c, t) =>
+        setProgress({ phase: 'Extracting frames', current: c, total: t })
+      );
+
+      setProgress({ phase: 'Converting frames', current: 0, total: frames.length });
+      const yPlanes = frames.map((frame, i) => {
+        setProgress({ phase: 'Converting frames', current: i + 1, total: frames.length });
+        return rgbaToY(frame);
+      });
+
+      setProgress({ phase: 'Trying all presets', current: 0, total: 0 });
+      const detection = autoDetectMultiFrame(yPlanes, width, height, key);
+
+      setResult(detection);
+    } catch (e) {
+      console.error('Detection error:', e);
+      alert(`Error: ${e}`);
+    } finally {
+      setProcessing(false);
+    }
+  };
+
+  return (
+    <div className="space-y-8">
+      {/* Upload area */}
+      <div
+        onDrop={handleDrop}
+        onDragOver={(e) => e.preventDefault()}
+        onClick={() => fileRef.current?.click()}
+        className={`group cursor-pointer rounded-xl border-2 border-dashed p-10 text-center transition-colors
+          ${videoUrl
+            ? 'border-zinc-700 bg-zinc-900/30'
+            : 'border-zinc-800 bg-zinc-900/20 hover:border-zinc-600 hover:bg-zinc-900/40'
+          }`}
+      >
+        <input
+          ref={fileRef}
+          type="file"
+          accept="video/*"
+          className="hidden"
+          onChange={(e) => {
+            const file = e.target.files?.[0];
+            if (file) handleFile(file);
+          }}
+        />
+        {videoUrl ? (
+          <div className="space-y-2">
+            <p className="text-sm font-medium text-zinc-300">{videoName}</p>
+            <p className="text-xs text-zinc-500">Click or drop to replace</p>
+          </div>
+        ) : (
+          <div className="space-y-2">
+            <svg className="mx-auto h-8 w-8 text-zinc-600 transition-colors group-hover:text-zinc-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={1.5}>
+              <path strokeLinecap="round" strokeLinejoin="round" d="M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z" />
+            </svg>
+            <p className="text-sm text-zinc-400">Drop a video file to analyze</p>
+            <p className="text-xs text-zinc-600">Upload a potentially watermarked video</p>
+          </div>
+        )}
+      </div>
+
+      {/* Configuration — just key and frame count */}
+      <div className="grid gap-6 sm:grid-cols-2">
+        <div className="space-y-1.5">
+          <label className="text-sm font-medium text-zinc-300">Secret Key</label>
+          <input
+            type="text"
+            value={key}
+            onChange={(e) => setKey(e.target.value)}
+            placeholder="Enter the secret key used for embedding..."
+            className="w-full rounded-lg border border-zinc-800 bg-zinc-900/50 px-3 py-2 text-sm text-zinc-100
+              placeholder:text-zinc-600 focus:border-blue-600 focus:outline-none focus:ring-1 focus:ring-blue-600"
+          />
+        </div>
+
+        <div className="space-y-1.5">
+          <label className="text-sm font-medium text-zinc-300">Frames to analyze</label>
+          <input
+            type="number"
+            value={maxFrames}
+            onChange={(e) => setMaxFrames(Math.max(1, Math.min(100, parseInt(e.target.value) || 10)))}
+            min={1}
+            max={100}
+            className="w-full rounded-lg border border-zinc-800 bg-zinc-900/50 px-3 py-2 text-sm text-zinc-100
+              focus:border-blue-600 focus:outline-none focus:ring-1 focus:ring-blue-600"
+          />
+          <p className="text-[10px] text-zinc-600">More frames = better detection, slower processing</p>
+        </div>
+      </div>
+
+      <p className="text-xs text-zinc-500">
+        All presets will be tried automatically. No need to know which preset was used during embedding.
+      </p>
+
+      {/* Detect button */}
+      <button
+        onClick={handleDetect}
+        disabled={!videoUrl || !key || processing}
+        className="w-full rounded-lg bg-violet-600 px-4 py-2.5 text-sm font-medium text-white
+          transition-colors hover:bg-violet-500 disabled:cursor-not-allowed disabled:bg-zinc-800 disabled:text-zinc-500"
+      >
+        {processing ? (
+          <span className="flex items-center justify-center gap-2">
+            <span className="h-4 w-4 animate-spin rounded-full border-2 border-zinc-400 border-t-white" />
+            {progress.phase} {progress.total > 0 ? `${progress.current}/${progress.total}` : ''}
+          </span>
+        ) : (
+          'Detect Watermark'
+        )}
+      </button>
+
+      {/* Results */}
+      <ResultCard result={result} presetUsed={result?.presetUsed ?? null} loading={processing} />
+    </div>
+  );
+}

web/src/components/EmbedPanel.tsx

@@ -0,0 +1,279 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import type { PresetName } from '@core/types.js';
+import { getPreset, PRESET_DESCRIPTIONS } from '@core/presets.js';
+import { streamExtractAndEmbed } from '../lib/video-io.js';
+import StrengthSlider from './StrengthSlider.js';
+import ComparisonView from './ComparisonView.js';
+import RobustnessTest from './RobustnessTest.js';
+
+const PLEASE_HOLD = [
+  { art: '  (•_•)\n  ( •_•)>⌐■-■\n  (⌐■_■)', caption: 'Putting on invisibility shades...' },
+  { art: '  ┌(▀Ĺ̯▀)┐\n  ┌(▀Ĺ̯▀)┘\n  └(▀Ĺ̯▀)┐', caption: 'Robot dance while we wait...' },
+  { art: '  ╔══╗\n  ║▓▓║  ☕\n  ╚══╝', caption: 'Brewing the perfect watermark...' },
+  { art: '  🎬 → 🔬 → 💎', caption: 'Turning pixels into secrets...' },
+  { art: '  [▓▓▓░░░░░░░]\n  [▓▓▓▓▓░░░░░]\n  [▓▓▓▓▓▓▓▓░░]', caption: 'Hiding bits in plain sight...' },
+  { art: '    /\\_/\\\n   ( o.o )\n    > ^ <', caption: 'Even the cat can\'t see the watermark...' },
+  { art: '  ┌─────────┐\n  │ 01101001 │\n  └─────────┘', caption: 'Whispering bits into wavelets...' },
+  { art: '  ~~ 🌊 ~~\n  ~🏄~ ~~ \n  ~~~~~~~~', caption: 'Surfing the frequency domain...' },
+  { art: '  📼 ➜ 🧬 ➜ 📼', caption: 'Splicing invisible DNA into frames...' },
+  { art: '  ¯\\_(ツ)_/¯', caption: 'Trust us, the watermark is there...' },
+];
+
+/** Max frames to keep in memory for the comparison view */
+const COMPARISON_SAMPLE = 30;
+
+export default function EmbedPanel() {
+  const [videoUrl, setVideoUrl] = useState<string | null>(null);
+  const [videoName, setVideoName] = useState('');
+  const [key, setKey] = useState('');
+  const [payload, setPayload] = useState('DEADBEEF');
+  const [preset, setPreset] = useState<PresetName>('moderate');
+  const [alpha, setAlpha] = useState(0.33);
+  const [processing, setProcessing] = useState(false);
+  const [progress, setProgress] = useState({ phase: '', current: 0, total: 0 });
+  const [jokeIndex, setJokeIndex] = useState(0);
+  const [result, setResult] = useState<{
+    blob: Blob;
+    psnr: number;
+    frames: number;
+    originalFrames: ImageData[];
+    watermarkedFrames: ImageData[];
+    width: number;
+    height: number;
+    fps: number;
+  } | null>(null);
+  const fileRef = useRef<HTMLInputElement>(null);
+
+  // Rotate jokes every 4s while processing
+  useEffect(() => {
+    if (!processing) return;
+    setJokeIndex(Math.floor(Math.random() * PLEASE_HOLD.length));
+    const id = setInterval(() => {
+      setJokeIndex((i) => (i + 1) % PLEASE_HOLD.length);
+    }, 4000);
+    return () => clearInterval(id);
+  }, [processing]);
+
+  const handleFile = useCallback((file: File) => {
+    const url = URL.createObjectURL(file);
+    setVideoUrl(url);
+    setVideoName(file.name);
+    setResult(null);
+  }, [result]);
+
+  const handleDrop = useCallback(
+    (e: React.DragEvent) => {
+      e.preventDefault();
+      const file = e.dataTransfer.files[0];
+      if (file?.type.startsWith('video/')) handleFile(file);
+    },
+    [handleFile]
+  );
+
+  const handleEmbed = async () => {
+    if (!videoUrl || !key) return;
+    setProcessing(true);
+    setResult(null);
+
+    try {
+      // Parse payload
+      const payloadHex = payload.replace(/^0x/, '');
+      const payloadBytes = new Uint8Array(
+        (payloadHex.length % 2 ? '0' + payloadHex : payloadHex)
+          .match(/.{2}/g)!
+          .map((b) => parseInt(b, 16))
+      );
+
+      const config = getPreset(preset);
+
+      // Stream: extract -> watermark -> encode in chunks
+      const embedResult = await streamExtractAndEmbed(
+        videoUrl,
+        payloadBytes,
+        key,
+        config,
+        COMPARISON_SAMPLE,
+        (phase, current, total) => setProgress({ phase, current, total })
+      );
+
+      setResult({
+        blob: embedResult.blob,
+        psnr: embedResult.avgPsnr,
+        frames: embedResult.totalFrames,
+        originalFrames: embedResult.sampleOriginal,
+        watermarkedFrames: embedResult.sampleWatermarked,
+        width: embedResult.width,
+        height: embedResult.height,
+        fps: embedResult.fps,
+      });
+    } catch (e) {
+      console.error('Embed error:', e);
+      alert(`Error: ${e}`);
+    } finally {
+      setProcessing(false);
+    }
+  };
+
+  const handleDownload = () => {
+    if (!result) return;
+    const url = URL.createObjectURL(result.blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = videoName.replace(/\.[^.]+$/, '') + '_watermarked.mp4';
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+
+  const maxPayloadHexChars = 8; // Always 32 bits = 8 hex chars
+
+  return (
+    <div className="space-y-8">
+      {/* Upload area */}
+      <div
+        onDrop={handleDrop}
+        onDragOver={(e) => e.preventDefault()}
+        onClick={() => fileRef.current?.click()}
+        className={`group cursor-pointer rounded-2xl border-2 border-dashed p-10 text-center transition-all duration-200
+          ${videoUrl
+            ? 'border-zinc-700 bg-zinc-900/30'
+            : 'border-zinc-800 bg-zinc-900/20 hover:border-blue-600/40 hover:bg-zinc-900/40 hover:shadow-lg hover:shadow-blue-600/5'
+          }`}
+      >
+        <input
+          ref={fileRef}
+          type="file"
+          accept="video/*"
+          className="hidden"
+          onChange={(e) => {
+            const file = e.target.files?.[0];
+            if (file) handleFile(file);
+          }}
+        />
+        {videoUrl ? (
+          <div className="space-y-2">
+            <p className="text-sm font-medium text-zinc-300">🎬 {videoName}</p>
+            <p className="text-xs text-zinc-500">Click or drop to replace</p>
+          </div>
+        ) : (
+          <div className="space-y-3">
+            <div className="mx-auto flex h-12 w-12 items-center justify-center rounded-xl bg-zinc-800/80 transition-colors group-hover:bg-blue-600/10">
+              <svg className="h-6 w-6 text-zinc-500 transition-colors group-hover:text-blue-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={1.5}>
+                <path strokeLinecap="round" strokeLinejoin="round" d="M3 16.5v2.25A2.25 2.25 0 005.25 21h13.5A2.25 2.25 0 0021 18.75V16.5m-13.5-9L12 3m0 0l4.5 4.5M12 3v13.5" />
+              </svg>
+            </div>
+            <p className="text-sm text-zinc-400">Drop a video file or click to browse</p>
+            <p className="text-xs text-zinc-600">MP4, WebM, MOV supported</p>
+          </div>
+        )}
+      </div>
+
+      {/* Configuration */}
+      <div className="grid gap-6 sm:grid-cols-2">
+        <div className="space-y-1.5">
+          <label className="text-sm font-medium text-zinc-300">🔑 Secret Key</label>
+          <input
+            type="text"
+            value={key}
+            onChange={(e) => setKey(e.target.value)}
+            placeholder="Enter a secret key..."
+            className="w-full rounded-lg border border-zinc-800 bg-zinc-900/50 px-3 py-2 text-sm text-zinc-100
+              placeholder:text-zinc-600 focus:border-blue-600 focus:outline-none focus:ring-1 focus:ring-blue-600
+              transition-colors"
+          />
+        </div>
+
+        <div className="space-y-1.5">
+          <label className="text-sm font-medium text-zinc-300">📦 Payload (hex)</label>
+          <input
+            type="text"
+            value={payload}
+            onChange={(e) => setPayload(e.target.value.replace(/[^0-9a-fA-F]/g, '').slice(0, maxPayloadHexChars))}
+            placeholder="DEADBEEF"
+            className="w-full rounded-lg border border-zinc-800 bg-zinc-900/50 px-3 py-2 font-mono text-sm text-zinc-100
+              placeholder:text-zinc-600 focus:border-blue-600 focus:outline-none focus:ring-1 focus:ring-blue-600
+              transition-colors"
+          />
+          <p className="text-[10px] text-zinc-600">32-bit payload, 4 bytes hex</p>
+        </div>
+      </div>
+
+      <StrengthSlider
+        value={alpha}
+        onChange={(v, p) => {
+          setAlpha(v);
+          setPreset(p);
+        }}
+        disabled={processing}
+      />
+
+      <p className="text-xs text-zinc-500">
+        {PRESET_DESCRIPTIONS[preset]}
+      </p>
+
+      {/* Embed button */}
+      <button
+        onClick={handleEmbed}
+        disabled={!videoUrl || !key || processing}
+        className="w-full rounded-xl bg-gradient-to-r from-blue-600 to-blue-500 px-4 py-3 text-sm font-semibold text-white
+          shadow-lg shadow-blue-600/20 transition-all hover:from-blue-500 hover:to-blue-400 hover:shadow-blue-500/30
+          disabled:cursor-not-allowed disabled:from-zinc-800 disabled:to-zinc-800 disabled:text-zinc-500 disabled:shadow-none"
+      >
+        {processing ? (
+          <span className="flex items-center justify-center gap-2">
+            <span className="h-4 w-4 animate-spin rounded-full border-2 border-zinc-400 border-t-white" />
+            {progress.phase} {progress.total > 0 ? `${progress.current}/${progress.total}` : ''}
+          </span>
+        ) : (
+          '✨ Embed Watermark'
+        )}
+      </button>
+
+      {/* Please-hold jokes while processing */}
+      {processing && (
+        <div className="flex flex-col items-center gap-2 rounded-xl bg-zinc-900/50 py-6 text-center">
+          <pre className="font-mono text-sm leading-tight text-zinc-400">
+            {PLEASE_HOLD[jokeIndex].art}
+          </pre>
+          <p className="text-xs text-zinc-500">{PLEASE_HOLD[jokeIndex].caption}</p>
+        </div>
+      )}
+
+      {/* Results */}
+      {result && (
+        <div className="space-y-6 rounded-2xl border border-emerald-800/30 bg-emerald-950/10 p-6">
+          <div className="flex items-center justify-between">
+            <div>
+              <h3 className="text-sm font-semibold text-emerald-400">✅ Embedding Complete</h3>
+              <p className="mt-1 text-xs text-zinc-500">
+                {result.frames} frames processed �� Average PSNR: {result.psnr.toFixed(1)} dB
+              </p>
+            </div>
+            <button
+              onClick={handleDownload}
+              className="rounded-lg bg-emerald-600/20 px-4 py-2 text-sm font-medium text-emerald-400
+                ring-1 ring-emerald-600/30 transition-all hover:bg-emerald-600/30 hover:ring-emerald-500/40"
+            >
+              ⬇️ Download
+            </button>
+          </div>
+
+          <ComparisonView
+            originalFrames={result.originalFrames}
+            watermarkedFrames={result.watermarkedFrames}
+            width={result.width}
+            height={result.height}
+            fps={result.fps}
+          />
+
+          <RobustnessTest
+            blob={result.blob}
+            width={result.width}
+            height={result.height}
+            payload={payload}
+            secretKey={key}
+          />
+        </div>
+      )}
+    </div>
+  );
+}

web/src/components/ResultCard.tsx

@@ -0,0 +1,102 @@
+import type { DetectionResult, PresetName } from '@core/types.js';
+
+interface ResultCardProps {
+  result: DetectionResult | null;
+  presetUsed?: PresetName | null;
+  loading?: boolean;
+}
+
+export default function ResultCard({ result, presetUsed, loading }: ResultCardProps) {
+  if (loading) {
+    return (
+      <div className="rounded-xl border border-zinc-800/50 bg-zinc-900/50 p-6">
+        <div className="flex items-center gap-3">
+          <div className="h-5 w-5 animate-spin rounded-full border-2 border-zinc-600 border-t-blue-500" />
+          <span className="text-sm text-zinc-400">Analyzing frames...</span>
+        </div>
+      </div>
+    );
+  }
+
+  if (!result) return null;
+
+  const payloadHex = result.payload
+    ? Array.from(result.payload).map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase()
+    : '—';
+
+  return (
+    <div
+      className={`rounded-xl border p-6 transition-colors ${
+        result.detected
+          ? 'border-emerald-800/50 bg-emerald-950/30'
+          : 'border-amber-800/50 bg-amber-950/20'
+      }`}
+    >
+      <div className="flex items-start justify-between">
+        <div>
+          <h3 className={`text-sm font-semibold ${result.detected ? 'text-emerald-400' : 'text-amber-400'}`}>
+            {result.detected ? 'Watermark Detected' : 'No Watermark Found'}
+          </h3>
+
+          {result.detected && (
+            <div className="mt-4 space-y-3">
+              <div>
+                <p className="text-[10px] uppercase tracking-wider text-zinc-500">Payload</p>
+                <p className="mt-0.5 font-mono text-lg tracking-wide text-zinc-100">{payloadHex}</p>
+              </div>
+
+              <div className="flex gap-6">
+                <div>
+                  <p className="text-[10px] uppercase tracking-wider text-zinc-500">Confidence</p>
+                  <div className="mt-1 flex items-center gap-2">
+                    <div className="h-1.5 w-24 overflow-hidden rounded-full bg-zinc-800">
+                      <div
+                        className="h-full rounded-full bg-emerald-500 transition-all"
+                        style={{ width: `${result.confidence * 100}%` }}
+                      />
+                    </div>
+                    <span className="text-xs tabular-nums text-zinc-400">
+                      {(result.confidence * 100).toFixed(1)}%
+                    </span>
+                  </div>
+                </div>
+
+                <div>
+                  <p className="text-[10px] uppercase tracking-wider text-zinc-500">Tiles used</p>
+                  <p className="mt-0.5 text-sm tabular-nums text-zinc-300">
+                    {result.tilesDecoded} of {result.tilesTotal} available
+                  </p>
+                </div>
+
+                {presetUsed && (
+                  <div>
+                    <p className="text-[10px] uppercase tracking-wider text-zinc-500">Preset</p>
+                    <p className="mt-0.5 text-sm capitalize text-zinc-300">
+                      {presetUsed}
+                    </p>
+                  </div>
+                )}
+              </div>
+            </div>
+          )}
+        </div>
+
+        <div
+          className={`flex h-10 w-10 items-center justify-center rounded-full ${
+            result.detected ? 'bg-emerald-500/10' : 'bg-amber-500/10'
+          }`}
+        >
+          {result.detected ? (
+            <svg className="h-5 w-5 text-emerald-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+              <path strokeLinecap="round" strokeLinejoin="round" d="M9 12l2 2 4-4m5.618-4.016A11.955 11.955 0 0112 2.944a11.955 11.955 0 01-8.618 3.04A12.02 12.02 0 003 9c0 5.591 3.824 10.29 9 11.622 5.176-1.332 9-6.03 9-11.622 0-1.042-.133-2.052-.382-3.016z" />
+            </svg>
+          ) : (
+            <svg className="h-5 w-5 text-amber-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+              <path strokeLinecap="round" strokeLinejoin="round" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4.5c-.77-.833-2.694-.833-3.464 0L3.34 16.5c-.77.833.192 2.5 1.732 2.5z" />
+            </svg>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

web/src/components/RobustnessTest.tsx

@@ -0,0 +1,167 @@
+import { useState, useCallback } from 'react';
+import { autoDetectMultiFrame } from '@core/detector.js';
+import { attackReencode, attackDownscale, attackBrightness, attackContrast, attackSaturation } from '../lib/video-io.js';
+
+type TestStatus = 'idle' | 'running' | 'pass' | 'fail' | 'error';
+
+interface TestResult {
+  status: TestStatus;
+  confidence?: number;
+  payloadMatch?: boolean;
+}
+
+interface RobustnessTestProps {
+  blob: Blob;
+  width: number;
+  height: number;
+  payload: string;
+  secretKey: string;
+}
+
+interface TestDef {
+  label: string;
+  category: string;
+  run: (blob: Blob, w: number, h: number) => Promise<{ yPlanes: Uint8Array[]; width: number; height: number }>;
+}
+
+const TESTS: TestDef[] = [
+  // CRF re-encoding
+  { label: 'CRF 23', category: 'Re-encode', run: (b, w, h) => attackReencode(b, 23, w, h) },
+  { label: 'CRF 28', category: 'Re-encode', run: (b, w, h) => attackReencode(b, 28, w, h) },
+  { label: 'CRF 33', category: 'Re-encode', run: (b, w, h) => attackReencode(b, 33, w, h) },
+  { label: 'CRF 38', category: 'Re-encode', run: (b, w, h) => attackReencode(b, 38, w, h) },
+  { label: 'CRF 43', category: 'Re-encode', run: (b, w, h) => attackReencode(b, 43, w, h) },
+  // Downscale
+  { label: '50%', category: 'Downscale', run: (b, w, h) => attackDownscale(b, 50, w, h) },
+  { label: '75%', category: 'Downscale', run: (b, w, h) => attackDownscale(b, 75, w, h) },
+  { label: '90%', category: 'Downscale', run: (b, w, h) => attackDownscale(b, 90, w, h) },
+  // Brightness
+  { label: '-0.2', category: 'Brightness', run: (b, w, h) => attackBrightness(b, -0.2, w, h) },
+  { label: '+0.2', category: 'Brightness', run: (b, w, h) => attackBrightness(b, 0.2, w, h) },
+  { label: '+0.4', category: 'Brightness', run: (b, w, h) => attackBrightness(b, 0.4, w, h) },
+  // Contrast
+  { label: '0.5x', category: 'Contrast', run: (b, w, h) => attackContrast(b, 0.5, w, h) },
+  { label: '1.5x', category: 'Contrast', run: (b, w, h) => attackContrast(b, 1.5, w, h) },
+  { label: '2.0x', category: 'Contrast', run: (b, w, h) => attackContrast(b, 2.0, w, h) },
+  // Saturation
+  { label: '0x', category: 'Saturation', run: (b, w, h) => attackSaturation(b, 0, w, h) },
+  { label: '0.5x', category: 'Saturation', run: (b, w, h) => attackSaturation(b, 0.5, w, h) },
+  { label: '2.0x', category: 'Saturation', run: (b, w, h) => attackSaturation(b, 2.0, w, h) },
+];
+
+function payloadToHex(payload: Uint8Array): string {
+  return Array.from(payload).map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase();
+}
+
+export default function RobustnessTest({ blob, width, height, payload, secretKey }: RobustnessTestProps) {
+  const [results, setResults] = useState<Record<number, TestResult>>({});
+  const [runningAll, setRunningAll] = useState(false);
+
+  const expectedHex = payload.replace(/^0x/, '').toUpperCase();
+
+  const runTest = useCallback(async (idx: number) => {
+    setResults((prev) => ({ ...prev, [idx]: { status: 'running' } }));
+    try {
+      const test = TESTS[idx];
+      const attacked = await test.run(blob, width, height);
+
+      // Pipeline already caps at 30 frames; use up to 10 evenly spaced
+      const step = Math.max(1, Math.floor(attacked.yPlanes.length / 10));
+      const sampled = attacked.yPlanes.filter((_, i) => i % step === 0).slice(0, 10);
+
+      const detection = autoDetectMultiFrame(sampled, attacked.width, attacked.height, secretKey);
+
+      const detectedHex = detection.payload ? payloadToHex(detection.payload) : '';
+      const match = detection.detected && detectedHex === expectedHex;
+
+      setResults((prev) => ({
+        ...prev,
+        [idx]: {
+          status: match ? 'pass' : 'fail',
+          confidence: detection.confidence,
+          payloadMatch: match,
+        },
+      }));
+    } catch (e) {
+      console.error(`Robustness test ${idx} error:`, e);
+      setResults((prev) => ({ ...prev, [idx]: { status: 'error' } }));
+    }
+  }, [blob, width, height, secretKey, expectedHex]);
+
+  const runAll = useCallback(async () => {
+    setRunningAll(true);
+    for (let i = 0; i < TESTS.length; i++) {
+      await runTest(i);
+    }
+    setRunningAll(false);
+  }, [runTest]);
+
+  const categories = ['Re-encode', 'Downscale', 'Brightness', 'Contrast', 'Saturation'];
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <h4 className="text-sm font-semibold text-zinc-300">Robustness Testing</h4>
+        <button
+          onClick={runAll}
+          disabled={runningAll}
+          className="rounded-lg bg-zinc-800 px-3 py-1.5 text-xs font-medium text-zinc-300
+            ring-1 ring-zinc-700 transition-all hover:bg-zinc-700 hover:text-zinc-100
+            disabled:cursor-not-allowed disabled:opacity-50"
+        >
+          {runningAll ? (
+            <span className="flex items-center gap-1.5">
+              <span className="h-3 w-3 animate-spin rounded-full border-[1.5px] border-zinc-500 border-t-zinc-200" />
+              Running...
+            </span>
+          ) : (
+            'Run All Tests'
+          )}
+        </button>
+      </div>
+
+      <div className="space-y-3">
+        {categories.map((cat) => {
+          const catTests = TESTS.map((t, i) => ({ ...t, idx: i })).filter((t) => t.category === cat);
+          return (
+            <div key={cat} className="flex items-center gap-2">
+              <span className="w-24 shrink-0 text-xs text-zinc-500">{cat}</span>
+              <div className="flex flex-wrap gap-1.5">
+                {catTests.map(({ label, idx }) => {
+                  const r = results[idx];
+                  const status = r?.status ?? 'idle';
+                  return (
+                    <button
+                      key={idx}
+                      onClick={() => runTest(idx)}
+                      disabled={status === 'running' || runningAll}
+                      className={`inline-flex items-center gap-1 rounded-md px-2.5 py-1 text-xs font-medium
+                        ring-1 transition-all disabled:cursor-not-allowed
+                        ${status === 'idle' ? 'bg-zinc-800/80 text-zinc-400 ring-zinc-700 hover:bg-zinc-700 hover:text-zinc-200' : ''}
+                        ${status === 'running' ? 'bg-zinc-800 text-zinc-400 ring-zinc-700' : ''}
+                        ${status === 'pass' ? 'bg-emerald-950/40 text-emerald-400 ring-emerald-800/50' : ''}
+                        ${status === 'fail' ? 'bg-red-950/40 text-red-400 ring-red-800/50' : ''}
+                        ${status === 'error' ? 'bg-amber-950/40 text-amber-400 ring-amber-800/50' : ''}
+                      `}
+                    >
+                      {status === 'running' && (
+                        <span className="h-3 w-3 animate-spin rounded-full border-[1.5px] border-zinc-500 border-t-zinc-200" />
+                      )}
+                      {status === 'pass' && <span>&#x2705;</span>}
+                      {status === 'fail' && <span>&#x274C;</span>}
+                      {status === 'error' && <span>&#x26A0;&#xFE0F;</span>}
+                      {label}
+                      {r?.confidence !== undefined && (
+                        <span className="ml-0.5 opacity-70">{(r.confidence * 100).toFixed(0)}%</span>
+                      )}
+                    </button>
+                  );
+                })}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}

web/src/components/StrengthSlider.tsx

@@ -0,0 +1,91 @@
+import type { PresetName } from '@core/types.js';
+
+const PRESET_MARKS: Array<{ value: number; label: string; emoji: string; preset: PresetName }> = [
+  { value: 0.00, label: 'Light', emoji: '🌤️', preset: 'light' },
+  { value: 0.33, label: 'Moderate', emoji: '⚡', preset: 'moderate' },
+  { value: 0.67, label: 'Strong', emoji: '🛡️', preset: 'strong' },
+  { value: 1.00, label: 'Fortress', emoji: '🏰', preset: 'fortress' },
+];
+
+interface StrengthSliderProps {
+  value: number;
+  onChange: (value: number, preset: PresetName) => void;
+  disabled?: boolean;
+}
+
+export default function StrengthSlider({ value, onChange, disabled }: StrengthSliderProps) {
+  const nearestPreset = PRESET_MARKS.reduce((best, mark) =>
+    Math.abs(mark.value - value) < Math.abs(best.value - value) ? mark : best
+  );
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-between">
+        <label className="text-sm font-medium text-zinc-300">Strength</label>
+        <span className="text-xs tabular-nums text-zinc-500">
+          {nearestPreset.emoji} {nearestPreset.label}
+        </span>
+      </div>
+
+      <div className="relative">
+        <input
+          type="range"
+          min="0"
+          max="1"
+          step="0.01"
+          value={value}
+          disabled={disabled}
+          onChange={(e) => {
+            const v = parseFloat(e.target.value);
+            const snap = PRESET_MARKS.find((m) => Math.abs(m.value - v) < 0.04);
+            if (snap) {
+              onChange(snap.value, snap.preset);
+            } else {
+              // Snap to nearest preset (no custom mode)
+              const nearest = PRESET_MARKS.reduce((best, mark) =>
+                Math.abs(mark.value - v) < Math.abs(best.value - v) ? mark : best
+              );
+              onChange(nearest.value, nearest.preset);
+            }
+          }}
+          className="w-full h-1.5 rounded-full appearance-none cursor-pointer
+            bg-zinc-700 accent-blue-500
+            disabled:opacity-50 disabled:cursor-not-allowed
+            [&::-webkit-slider-thumb]:appearance-none
+            [&::-webkit-slider-thumb]:w-4
+            [&::-webkit-slider-thumb]:h-4
+            [&::-webkit-slider-thumb]:rounded-full
+            [&::-webkit-slider-thumb]:bg-blue-500
+            [&::-webkit-slider-thumb]:shadow-lg
+            [&::-webkit-slider-thumb]:shadow-blue-500/20
+            [&::-webkit-slider-thumb]:transition-transform
+            [&::-webkit-slider-thumb]:hover:scale-110"
+        />
+
+        <div className="relative mt-2 h-5">
+          {PRESET_MARKS.map((mark, i) => {
+            const pct = mark.value * 100;
+            const isFirst = i === 0;
+            const isLast = i === PRESET_MARKS.length - 1;
+            const align = isFirst ? 'left-0' : isLast ? 'right-0' : '-translate-x-1/2';
+            return (
+              <button
+                key={mark.preset}
+                onClick={() => onChange(mark.value, mark.preset)}
+                disabled={disabled}
+                style={isFirst || isLast ? undefined : { left: `${pct}%` }}
+                className={`absolute whitespace-nowrap text-[10px] transition-colors ${align} ${
+                  nearestPreset.preset === mark.preset
+                    ? 'text-blue-400 font-medium'
+                    : 'text-zinc-600 hover:text-zinc-400'
+                } disabled:opacity-50`}
+              >
+                {mark.emoji} {mark.label}
+              </button>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}

web/src/index.css

@@ -0,0 +1 @@
+@import "tailwindcss";

web/src/lib/video-io.ts

@@ -0,0 +1,408 @@
+/**
+ * Browser-based video frame extraction and re-encoding
+ * Uses ffmpeg.wasm for H.264 MP4 output
+ */
+
+import { FFmpeg } from '@ffmpeg/ffmpeg';
+import { toBlobURL } from '@ffmpeg/util';
+import type { WatermarkConfig } from '@core/types.js';
+import { embedWatermark } from '@core/embedder.js';
+
+let ffmpegInstance: FFmpeg | null = null;
+let ffmpegLoaded = false;
+
+/** Get or initialize the shared FFmpeg instance */
+async function getFFmpeg(onLog?: (msg: string) => void): Promise<FFmpeg> {
+  if (ffmpegInstance && ffmpegLoaded) return ffmpegInstance;
+
+  ffmpegInstance = new FFmpeg();
+  if (onLog) {
+    ffmpegInstance.on('log', ({ message }) => onLog(message));
+  }
+
+  // Load ffmpeg.wasm from CDN
+  const baseURL = 'https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm';
+  await ffmpegInstance.load({
+    coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, 'text/javascript'),
+    wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, 'application/wasm'),
+  });
+
+  ffmpegLoaded = true;
+  return ffmpegInstance;
+}
+
+/** Extract Y plane from an RGBA ImageData */
+export function rgbaToY(imageData: ImageData): Uint8Array {
+  const { data, width, height } = imageData;
+  const y = new Uint8Array(width * height);
+  for (let i = 0; i < width * height; i++) {
+    const r = data[i * 4];
+    const g = data[i * 4 + 1];
+    const b = data[i * 4 + 2];
+    y[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  }
+  return y;
+}
+
+/** Apply Y plane delta to RGBA ImageData (modifies in place) */
+export function applyYDelta(imageData: ImageData, originalY: Uint8Array, watermarkedY: Uint8Array): void {
+  const { data } = imageData;
+  for (let i = 0; i < originalY.length; i++) {
+    const delta = watermarkedY[i] - originalY[i];
+    data[i * 4] = Math.max(0, Math.min(255, data[i * 4] + delta));
+    data[i * 4 + 1] = Math.max(0, Math.min(255, data[i * 4 + 1] + delta));
+    data[i * 4 + 2] = Math.max(0, Math.min(255, data[i * 4 + 2] + delta));
+  }
+}
+
+/** Result of the streaming extract+embed pipeline */
+export interface StreamEmbedResult {
+  blob: Blob;
+  width: number;
+  height: number;
+  fps: number;
+  totalFrames: number;
+  avgPsnr: number;
+  sampleOriginal: ImageData[];
+  sampleWatermarked: ImageData[];
+}
+
+/** Number of frames to accumulate before flushing to H.264 encoder */
+const CHUNK_SIZE = 100;
+
+/**
+ * Streaming extract → watermark → encode pipeline.
+ * Processes frames in chunks of CHUNK_SIZE, encoding each chunk to a
+ * temporary MP4 segment and freeing the raw buffer. This keeps peak
+ * memory at ~(CHUNK_SIZE * frameSize) instead of (totalFrames * frameSize).
+ * At the end, all segments are concatenated into the final MP4.
+ */
+export async function streamExtractAndEmbed(
+  videoUrl: string,
+  payload: Uint8Array,
+  key: string,
+  config: WatermarkConfig,
+  comparisonSample: number,
+  onProgress?: (phase: string, current: number, total: number) => void
+): Promise<StreamEmbedResult> {
+  const video = document.createElement('video');
+  video.src = videoUrl;
+  video.muted = true;
+  video.preload = 'auto';
+
+  await new Promise<void>((resolve, reject) => {
+    video.onloadedmetadata = () => resolve();
+    video.onerror = () => reject(new Error('Failed to load video'));
+  });
+
+  const { videoWidth: rawW, videoHeight: rawH, duration } = video;
+  // x264 with yuv420p requires even dimensions
+  const width = rawW % 2 === 0 ? rawW : rawW - 1;
+  const height = rawH % 2 === 0 ? rawH : rawH - 1;
+  const totalFrames = Math.ceil(duration * 30);
+  const interval = duration / totalFrames;
+  const fps = totalFrames / duration;
+
+  const canvas = document.createElement('canvas');
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext('2d')!;
+
+  const frameSize = width * height * 4;
+
+  // Determine which frame indices to sample for comparison
+  const sampleIndices = new Set<number>();
+  const sampleStep = Math.max(1, Math.floor(totalFrames / comparisonSample));
+  for (let i = 0; i < totalFrames && sampleIndices.size < comparisonSample; i += sampleStep) {
+    sampleIndices.add(i);
+  }
+
+  const sampleOriginal: ImageData[] = [];
+  const sampleWatermarked: ImageData[] = [];
+  let totalPsnr = 0;
+
+  const ffmpeg = await getFFmpeg();
+  const segments: string[] = [];
+
+  // Chunk buffer — reused across chunks
+  let chunkBuffer = new Uint8Array(Math.min(CHUNK_SIZE, totalFrames) * frameSize);
+  let chunkOffset = 0;
+  let framesInChunk = 0;
+
+  const flushChunk = async () => {
+    if (framesInChunk === 0) return;
+
+    const segName = `seg_${segments.length}.mp4`;
+    const usedBytes = chunkBuffer.slice(0, framesInChunk * frameSize);
+    await ffmpeg.writeFile('chunk.raw', usedBytes);
+
+    await ffmpeg.exec([
+      '-f', 'rawvideo',
+      '-pix_fmt', 'rgba',
+      '-s', `${width}x${height}`,
+      '-r', String(fps),
+      '-i', 'chunk.raw',
+      '-c:v', 'libx264',
+      '-pix_fmt', 'yuv420p',
+      '-crf', '20',
+      '-preset', 'ultrafast',
+      '-an', '-y',
+      segName,
+    ]);
+
+    await ffmpeg.deleteFile('chunk.raw');
+    segments.push(segName);
+    chunkOffset = 0;
+    framesInChunk = 0;
+  };
+
+  for (let i = 0; i < totalFrames; i++) {
+    onProgress?.('Embedding', i + 1, totalFrames);
+
+    // Seek and extract frame
+    video.currentTime = i * interval;
+    await new Promise<void>((resolve) => {
+      video.onseeked = () => resolve();
+    });
+    ctx.drawImage(video, 0, 0, width, height);
+    const frameData = ctx.getImageData(0, 0, width, height);
+
+    // Watermark
+    const y = rgbaToY(frameData);
+    const result = embedWatermark(y, width, height, payload, key, config);
+    totalPsnr += result.psnr;
+
+    // Apply watermark delta to RGBA
+    applyYDelta(frameData, y, result.yPlane);
+
+    // Append to chunk buffer
+    chunkBuffer.set(frameData.data, chunkOffset);
+    chunkOffset += frameSize;
+    framesInChunk++;
+
+    // Keep sample frames for comparison
+    if (sampleIndices.has(i)) {
+      ctx.drawImage(video, 0, 0, width, height);
+      sampleOriginal.push(ctx.getImageData(0, 0, width, height));
+      sampleWatermarked.push(frameData);
+    }
+
+    // Flush chunk when full
+    if (framesInChunk >= CHUNK_SIZE) {
+      onProgress?.('Encoding chunk', segments.length + 1, Math.ceil(totalFrames / CHUNK_SIZE));
+      await flushChunk();
+    }
+  }
+
+  // Flush remaining frames
+  if (framesInChunk > 0) {
+    onProgress?.('Encoding chunk', segments.length + 1, Math.ceil(totalFrames / CHUNK_SIZE));
+    await flushChunk();
+  }
+
+  // Free chunk buffer
+  chunkBuffer = null!;
+
+  // Concatenate all segments
+  let blob: Blob;
+  if (segments.length === 1) {
+    // Single segment — just use it directly
+    const data = await ffmpeg.readFile(segments[0]);
+    await ffmpeg.deleteFile(segments[0]);
+    if (typeof data === 'string') throw new Error('Unexpected string output from ffmpeg');
+    blob = new Blob([(data as unknown as { buffer: ArrayBuffer }).buffer], { type: 'video/mp4' });
+  } else {
+    onProgress?.('Joining segments', 0, 0);
+    // Write concat file list
+    const concatList = segments.map((s) => `file '${s}'`).join('\n');
+    await ffmpeg.writeFile('concat.txt', concatList);
+
+    await ffmpeg.exec([
+      '-f', 'concat',
+      '-safe', '0',
+      '-i', 'concat.txt',
+      '-c', 'copy',
+      '-movflags', '+faststart',
+      '-y',
+      'final.mp4',
+    ]);
+
+    await ffmpeg.deleteFile('concat.txt');
+    for (const seg of segments) {
+      await ffmpeg.deleteFile(seg);
+    }
+
+    const data = await ffmpeg.readFile('final.mp4');
+    await ffmpeg.deleteFile('final.mp4');
+    if (typeof data === 'string') throw new Error('Unexpected string output from ffmpeg');
+    blob = new Blob([(data as unknown as { buffer: ArrayBuffer }).buffer], { type: 'video/mp4' });
+  }
+
+  return {
+    blob,
+    width,
+    height,
+    fps,
+    totalFrames,
+    avgPsnr: totalPsnr / totalFrames,
+    sampleOriginal,
+    sampleWatermarked,
+  };
+}
+
+/**
+ * Extract frames from a video (used by detect panel).
+ * Spreads frames evenly across the full duration.
+ */
+export async function extractFrames(
+  videoUrl: string,
+  maxFrames: number = 30,
+  onProgress?: (frame: number, total: number) => void
+): Promise<{ frames: ImageData[]; width: number; height: number; fps: number; duration: number }> {
+  const video = document.createElement('video');
+  video.src = videoUrl;
+  video.muted = true;
+  video.preload = 'auto';
+
+  await new Promise<void>((resolve, reject) => {
+    video.onloadedmetadata = () => resolve();
+    video.onerror = () => reject(new Error('Failed to load video'));
+  });
+
+  const { videoWidth: rawW, videoHeight: rawH, duration } = video;
+  const width = rawW % 2 === 0 ? rawW : rawW - 1;
+  const height = rawH % 2 === 0 ? rawH : rawH - 1;
+  const nativeFrameCount = Math.ceil(duration * 30);
+  const totalFrames = Math.min(maxFrames, nativeFrameCount);
+  const interval = duration / totalFrames;
+
+  const canvas = document.createElement('canvas');
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext('2d')!;
+
+  const frames: ImageData[] = [];
+
+  for (let i = 0; i < totalFrames; i++) {
+    video.currentTime = i * interval;
+    await new Promise<void>((resolve) => {
+      video.onseeked = () => resolve();
+    });
+
+    ctx.drawImage(video, 0, 0, width, height);
+    frames.push(ctx.getImageData(0, 0, width, height));
+    onProgress?.(i + 1, totalFrames);
+  }
+
+  const fps = totalFrames / duration;
+
+  return { frames, width, height, fps, duration };
+}
+
+// ---------------------------------------------------------------------------
+// Attack utilities — apply degradation to watermarked MP4, return Y planes
+// ---------------------------------------------------------------------------
+
+/** Result of decoding an attacked video back to Y planes */
+export interface AttackYPlanes {
+  yPlanes: Uint8Array[];
+  width: number;
+  height: number;
+}
+
+/**
+ * Write blob to ffmpeg FS, run attack filter, decode output to Y planes.
+ * Only processes `maxFrames` frames to keep WASM encoding fast.
+ */
+async function runAttackPipeline(
+  blob: Blob,
+  filterArgs: string[],
+  outputWidth: number,
+  outputHeight: number,
+  maxFrames: number = 30,
+): Promise<AttackYPlanes> {
+  const ffmpeg = await getFFmpeg();
+
+  const inputData = new Uint8Array(await blob.arrayBuffer());
+  await ffmpeg.writeFile('attack_input.mp4', inputData);
+
+  await ffmpeg.exec([
+    '-i', 'attack_input.mp4',
+    ...filterArgs,
+    '-frames:v', String(maxFrames),
+    '-c:v', 'libx264',
+    '-pix_fmt', 'yuv420p',
+    '-preset', 'ultrafast',
+    '-an',
+    '-y',
+    'attack_output.mp4',
+  ]);
+
+  // Decode attacked output to raw grayscale
+  await ffmpeg.exec([
+    '-i', 'attack_output.mp4',
+    '-f', 'rawvideo',
+    '-pix_fmt', 'gray',
+    '-y',
+    'attack_raw.raw',
+  ]);
+
+  const rawData = await ffmpeg.readFile('attack_raw.raw');
+
+  await ffmpeg.deleteFile('attack_input.mp4');
+  await ffmpeg.deleteFile('attack_output.mp4');
+  await ffmpeg.deleteFile('attack_raw.raw');
+
+  if (typeof rawData === 'string') throw new Error('Unexpected string output from ffmpeg');
+  const raw = new Uint8Array((rawData as unknown as { buffer: ArrayBuffer }).buffer);
+
+  const frameSize = outputWidth * outputHeight;
+  const frameCount = Math.floor(raw.length / frameSize);
+  const yPlanes: Uint8Array[] = [];
+  for (let i = 0; i < frameCount; i++) {
+    yPlanes.push(raw.slice(i * frameSize, (i + 1) * frameSize));
+  }
+
+  return { yPlanes, width: outputWidth, height: outputHeight };
+}
+
+/** Attack: re-encode at a given CRF quality level */
+export async function attackReencode(blob: Blob, crf: number, width: number, height: number): Promise<AttackYPlanes> {
+  return runAttackPipeline(blob, ['-crf', String(crf)], width, height);
+}
+
+/** Attack: downscale to scalePct%, then scale back up to original size */
+export async function attackDownscale(
+  blob: Blob,
+  scalePct: number,
+  width: number,
+  height: number,
+): Promise<AttackYPlanes> {
+  const scaledW = Math.round(width * scalePct / 100);
+  const scaledH = Math.round(height * scalePct / 100);
+  // Ensure even dimensions for libx264
+  const sW = scaledW % 2 === 0 ? scaledW : scaledW + 1;
+  const sH = scaledH % 2 === 0 ? scaledH : scaledH + 1;
+  return runAttackPipeline(
+    blob,
+    ['-vf', `scale=${sW}:${sH},scale=${width}:${height}`, '-crf', '18'],
+    width,
+    height,
+  );
+}
+
+/** Attack: adjust brightness by delta (-1.0 to 1.0) */
+export async function attackBrightness(blob: Blob, delta: number, width: number, height: number): Promise<AttackYPlanes> {
+  return runAttackPipeline(blob, ['-vf', `eq=brightness=${delta}`, '-crf', '18'], width, height);
+}
+
+/** Attack: adjust contrast (1.0 = unchanged, <1 = less, >1 = more) */
+export async function attackContrast(blob: Blob, factor: number, width: number, height: number): Promise<AttackYPlanes> {
+  return runAttackPipeline(blob, ['-vf', `eq=contrast=${factor}`, '-crf', '18'], width, height);
+}
+
+/** Attack: adjust saturation (1.0 = unchanged, 0 = grayscale, >1 = boosted) */
+export async function attackSaturation(blob: Blob, factor: number, width: number, height: number): Promise<AttackYPlanes> {
+  return runAttackPipeline(blob, ['-vf', `eq=saturation=${factor}`, '-crf', '18'], width, height);
+}
+

web/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);

web/src/workers/watermark.worker.ts

@@ -0,0 +1,62 @@
+/**
+ * Web Worker for non-blocking watermark embedding/detection
+ */
+
+import { embedWatermark } from '@core/embedder.js';
+import { detectWatermark } from '@core/detector.js';
+import { getPreset } from '@core/presets.js';
+import type { PresetName, WatermarkConfig } from '@core/types.js';
+
+export type WorkerMessage =
+  | {
+      type: 'embed';
+      id: number;
+      yPlane: Uint8Array;
+      width: number;
+      height: number;
+      payload: Uint8Array;
+      key: string;
+      preset: PresetName;
+      customConfig?: Partial<WatermarkConfig>;
+    }
+  | {
+      type: 'detect';
+      id: number;
+      yPlane: Uint8Array;
+      width: number;
+      height: number;
+      key: string;
+      preset: PresetName;
+      customConfig?: Partial<WatermarkConfig>;
+    };
+
+self.onmessage = (e: MessageEvent<WorkerMessage>) => {
+  const msg = e.data;
+
+  try {
+    const config = getPreset(msg.preset);
+
+    if (msg.type === 'embed') {
+      const result = embedWatermark(msg.yPlane, msg.width, msg.height, msg.payload, msg.key, config);
+      self.postMessage({
+        type: 'embed-result',
+        id: msg.id,
+        yPlane: result.yPlane,
+        psnr: result.psnr,
+      });
+    } else if (msg.type === 'detect') {
+      const result = detectWatermark(msg.yPlane, msg.width, msg.height, msg.key, config);
+      self.postMessage({
+        type: 'detect-result',
+        id: msg.id,
+        ...result,
+      });
+    }
+  } catch (err) {
+    self.postMessage({
+      type: 'error',
+      id: msg.id,
+      error: String(err),
+    });
+  }
+};