@knights-eye-chess/ai-analysis 0.0.0-stage → 0.1.0-dev.14

package/dist/owner-tests/mechanism-encoding.test.mjs

@@ -0,0 +1,529 @@
+// test/owner/mechanism-encoding.test.mjs
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Chess as Chess3 } from "chess.js";
+
+// src/chess-reasoning/mechanism-presentation.ts
+var object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var COLUMNS = {
+  mover: ["pieceId", "pieceIdAfter", "fromSquare", "toSquare", "color", "pieceTypeBefore", "pieceTypeAfter", "attackersBefore", "attackersAfter"],
+  unmoved: ["pieceId", "square", "pieceType", "attackersBefore", "attackersAfter"],
+  rays: ["pieceId", "fromSquare", "color", "pieceType", "direction", "gainedSquares", "lostSquares"],
+  control: ["square", "color", "attackersBefore", "attackersAfter"]
+};
+var GROUPS = ["mover", "unmoved", "rays", "control"];
+function exactKeys(value, columns) {
+  return object(value) && Object.keys(value).length === columns.length && columns.every((column) => Object.hasOwn(value, column));
+}
+function encodeRows(value, columns) {
+  return columns.map((column) => value[column]);
+}
+function decodeRow(row, columns) {
+  if (!Array.isArray(row) || row.length !== columns.length) return null;
+  return Object.fromEntries(columns.map((column, index) => [column, row[index]]));
+}
+function expandMechanismPresentation(value) {
+  if (!object(value) || value.encoding !== "move-mechanism/1") return value;
+  if (!object(value.columns) || !object(value.rows) || Object.keys(value.columns).length !== GROUPS.length || Object.keys(value.rows).length !== GROUPS.length) return value;
+  for (const group of GROUPS) {
+    if (JSON.stringify(value.columns[group]) !== JSON.stringify(COLUMNS[group])) return value;
+  }
+  const mover = decodeRow(value.rows.mover, COLUMNS.mover);
+  if (!mover || !Array.isArray(value.rows.unmoved) || !Array.isArray(value.rows.rays) || !Array.isArray(value.rows.control)) return value;
+  const unmoved = value.rows.unmoved.map((row) => decodeRow(row, COLUMNS.unmoved));
+  const rays = value.rows.rays.map((row) => decodeRow(row, COLUMNS.rays));
+  const control = value.rows.control.map((row) => decodeRow(row, COLUMNS.control));
+  if ([...unmoved, ...rays, ...control].some((row) => row === null)) return value;
+  const { encoding: _encoding, columns: _columns, rows: _rows, ...rest } = value;
+  void _encoding;
+  void _columns;
+  void _rows;
+  return {
+    ...rest,
+    mover,
+    attackedUnmovedFriendlyPieces: unmoved,
+    stationarySliderRays: rays,
+    controlDelta: control
+  };
+}
+function compactMechanism(value, targetSquares) {
+  if (!object(value) || !Array.isArray(value.controlDelta)) return value;
+  const targets = [...new Set(targetSquares)].filter((s) => /^[a-h][1-8]$/.test(s));
+  const controlDelta = value.controlDelta.filter((d) => object(d) && targets.includes(String(d.square)));
+  const rays = Array.isArray(value.stationarySliderRays) ? value.stationarySliderRays.map((ray2) => {
+    if (!object(ray2)) return ray2;
+    const { beforeSquares: _before, afterSquares: _after, ...changes } = ray2;
+    void _before;
+    void _after;
+    return changes;
+  }) : value.stationarySliderRays;
+  const projected = {
+    ...value,
+    stationarySliderRays: rays,
+    controlDelta,
+    presentation: {
+      controlSquares: targets,
+      omittedControlDeltaCount: value.controlDelta.length - controlDelta.length,
+      scope: "All changed stationary rays and mover/unmoved attack measurements retained. Control deltas shown only for controlSquares; an omitted square is not checked-negative in this view. Full ray extents and all control deltas are retrievable."
+    }
+  };
+  if (!exactKeys(value, ["mover", "attackedUnmovedFriendlyPieces", "stationarySliderRays", "controlDelta", "checksRun", "scope"]) || !exactKeys(projected.mover, COLUMNS.mover) || !Array.isArray(projected.attackedUnmovedFriendlyPieces) || !projected.attackedUnmovedFriendlyPieces.every((item) => exactKeys(item, COLUMNS.unmoved)) || !Array.isArray(rays) || !rays.every((item) => exactKeys(item, COLUMNS.rays)) || !controlDelta.every((item) => exactKeys(item, COLUMNS.control))) return projected;
+  return {
+    encoding: "move-mechanism/1",
+    columns: COLUMNS,
+    rows: {
+      mover: encodeRows(projected.mover, COLUMNS.mover),
+      unmoved: projected.attackedUnmovedFriendlyPieces.map((item) => encodeRows(item, COLUMNS.unmoved)),
+      rays: rays.map((item) => encodeRows(item, COLUMNS.rays)),
+      control: controlDelta.map((item) => encodeRows(item, COLUMNS.control))
+    },
+    checksRun: projected.checksRun,
+    scope: projected.scope,
+    presentation: projected.presentation
+  };
+}
+
+// src/chess-reasoning/move-mechanism-facts.ts
+import { Chess as Chess2, SQUARES as SQUARES2 } from "chess.js";
+
+// src/chess-reasoning/piece-identities.ts
+import { Chess, SQUARES } from "chess.js";
+
+// src/chess-reasoning/types.ts
+var CHESS_REASONING_SCHEMA_VERSION = "0.2.0";
+
+// src/chess-reasoning/piece-identities.ts
+var PIECE_NAMES = {
+  p: "pawn",
+  n: "knight",
+  b: "bishop",
+  r: "rook",
+  q: "queen",
+  k: "king"
+};
+var COLOR_NAMES = { w: "white", b: "black" };
+function pieceId(color, type, square, ordinal = 0) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:${square}:${ordinal}`;
+}
+function promotionId(color, type, square, ordinal) {
+  return `${COLOR_NAMES[color]}-${PIECE_NAMES[type]}:promotion:${square}:${ordinal}`;
+}
+function clonePieces(pieces) {
+  return Object.fromEntries(Object.entries(pieces).map(([id, piece]) => [id, { ...piece }]));
+}
+function createIdentityState(fen = new Chess().fen(), branchId = "main", ply = 0) {
+  const chess = new Chess(fen);
+  const pieces = {};
+  const squares = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const square of SQUARES) {
+    const piece = chess.get(square);
+    if (!piece) continue;
+    const key = `${piece.color}:${piece.type}:${square}`;
+    const ordinal = seen.get(key) || 0;
+    seen.set(key, ordinal + 1);
+    const id = pieceId(piece.color, piece.type, square, ordinal);
+    pieces[id] = {
+      id,
+      color: piece.color,
+      type: piece.type,
+      originSquare: square,
+      createdPly: ply,
+      promotedFrom: null,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[square] = id;
+  }
+  return {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId,
+    fen: chess.fen(),
+    ply,
+    pieces,
+    squares,
+    promotionSequence: 0
+  };
+}
+function applyIdentityMove(state, moveInput) {
+  const chess = new Chess(state.fen);
+  const beforeFen = chess.fen();
+  const move = chess.move(moveInput);
+  const nextPly = state.ply + 1;
+  const pieces = clonePieces(state.pieces);
+  const squares = { ...state.squares };
+  const mover = squares[move.from];
+  if (!mover) throw new Error(`No stable piece identity at ${move.from}`);
+  let captured = null;
+  const capturedSquare = move.isEnPassant() ? `${move.to[0]}${move.from[1]}` : move.to;
+  if (move.isCapture() || move.isEnPassant()) {
+    captured = squares[capturedSquare] || null;
+    if (!captured) throw new Error(`No captured piece identity at ${capturedSquare}`);
+    pieces[captured] = { ...pieces[captured], capturedAtPly: nextPly };
+    delete squares[capturedSquare];
+  }
+  delete squares[move.from];
+  let rookMoved = null;
+  if (move.isKingsideCastle() || move.isQueensideCastle()) {
+    const rank = move.from[1];
+    const rookFrom = `${move.isKingsideCastle() ? "h" : "a"}${rank}`;
+    const rookTo = `${move.isKingsideCastle() ? "f" : "d"}${rank}`;
+    rookMoved = squares[rookFrom] || null;
+    if (!rookMoved) throw new Error(`No stable rook identity at ${rookFrom}`);
+    delete squares[rookFrom];
+    squares[rookTo] = rookMoved;
+  }
+  let promoted = null;
+  let promotionSequence = state.promotionSequence;
+  if (move.isPromotion()) {
+    promotionSequence += 1;
+    pieces[mover] = { ...pieces[mover], retiredAtPly: nextPly };
+    promoted = promotionId(move.color, move.promotion, move.to, promotionSequence);
+    pieces[promoted] = {
+      id: promoted,
+      color: move.color,
+      type: move.promotion,
+      originSquare: move.to,
+      createdPly: nextPly,
+      promotedFrom: mover,
+      capturedAtPly: null,
+      retiredAtPly: null
+    };
+    squares[move.to] = promoted;
+  } else {
+    squares[move.to] = mover;
+  }
+  const nextState = {
+    schemaVersion: CHESS_REASONING_SCHEMA_VERSION,
+    branchId: state.branchId,
+    fen: chess.fen(),
+    ply: nextPly,
+    pieces,
+    squares,
+    promotionSequence
+  };
+  return {
+    state: nextState,
+    delta: {
+      branchId: state.branchId,
+      ply: nextPly,
+      uci: `${move.from}${move.to}${move.promotion || ""}`,
+      san: move.san,
+      mover,
+      captured,
+      promoted,
+      rookMoved,
+      beforeFen,
+      afterFen: chess.fen()
+    }
+  };
+}
+
+// src/chess-reasoning/move-mechanism-facts.ts
+var DIRECTIONS = [
+  ["N", 0, 1],
+  ["NE", 1, 1],
+  ["E", 1, 0],
+  ["SE", 1, -1],
+  ["S", 0, -1],
+  ["SW", -1, -1],
+  ["W", -1, 0],
+  ["NW", -1, 1]
+];
+function enemy(color) {
+  return color === "w" ? "b" : "w";
+}
+function attackers(board, square, color) {
+  return board.attackers(square, color).sort((a, b) => SQUARES2.indexOf(a) - SQUARES2.indexOf(b));
+}
+function ray(board, origin, fileStep, rankStep) {
+  const squares = [];
+  const file = origin.charCodeAt(0) - 97;
+  const rank = Number(origin[1]) - 1;
+  for (let distance = 1; distance < 8; distance += 1) {
+    const f = file + fileStep * distance;
+    const r = rank + rankStep * distance;
+    if (f < 0 || f > 7 || r < 0 || r > 7) break;
+    const square = `${String.fromCharCode(97 + f)}${r + 1}`;
+    squares.push(square);
+    if (board.get(square)) break;
+  }
+  return squares;
+}
+function sliderDirections(type) {
+  if (type === "q") return DIRECTIONS;
+  return DIRECTIONS.filter(([, dx, dy]) => type === "r" ? !dx || !dy : !!dx && !!dy);
+}
+function moveMechanismFacts(before, after, from, to, beforeIds, afterIds) {
+  const moverBefore = before.get(from);
+  const moverAfter = after.get(to);
+  if (!moverBefore || !moverAfter || moverBefore.color !== moverAfter.color) {
+    throw new Error(`Move mechanism has no corresponding mover at ${from}-${to}`);
+  }
+  const beforeState = beforeIds || createIdentityState(before.fen());
+  if (beforeState.fen !== before.fen() || afterIds && afterIds.fen !== after.fen()) {
+    throw new Error("Move mechanism identity position does not match the board");
+  }
+  const actualMove = before.moves({ verbose: true }).find((move) => {
+    if (move.from !== from || move.to !== to) return false;
+    const replay = new Chess2(before.fen());
+    replay.move({ from, to, promotion: move.promotion });
+    return replay.fen() === after.fen();
+  });
+  if (!actualMove) throw new Error(`Move mechanism after-position is not a legal ${from}-${to} result`);
+  const afterState = afterIds || applyIdentityMove(beforeState, {
+    from,
+    to,
+    promotion: actualMove.promotion
+  }).state;
+  const pieceId2 = beforeState.squares[from];
+  const pieceIdAfter = afterState.squares[to];
+  if (!pieceId2 || !pieceIdAfter || (actualMove.promotion ? afterState.pieces[pieceIdAfter]?.promotedFrom !== pieceId2 : pieceIdAfter !== pieceId2)) {
+    throw new Error("Move mechanism mover identities do not match");
+  }
+  const attackedUnmovedFriendlyPieces = [];
+  const stationarySliderRays = [];
+  const color = moverBefore.color;
+  for (const square of SQUARES2) {
+    const piece = before.get(square);
+    const samePiece = after.get(square);
+    const id = beforeState.squares[square];
+    if (!piece || !samePiece || !id || afterState.squares[square] !== id || piece.color !== samePiece.color || piece.type !== samePiece.type) continue;
+    if (piece.color === color) {
+      const beforeAttackers = attackers(before, square, enemy(color));
+      const afterAttackers = attackers(after, square, enemy(color));
+      if (beforeAttackers.length || afterAttackers.length) {
+        attackedUnmovedFriendlyPieces.push({
+          pieceId: id,
+          square,
+          pieceType: piece.type,
+          attackersBefore: beforeAttackers,
+          attackersAfter: afterAttackers
+        });
+      }
+    }
+    if (piece.type !== "r" && piece.type !== "b" && piece.type !== "q") continue;
+    for (const [direction, dx, dy] of sliderDirections(piece.type)) {
+      const beforeSquares = ray(before, square, dx, dy);
+      const afterSquares = ray(after, square, dx, dy);
+      const beforeSet = new Set(beforeSquares);
+      const afterSet = new Set(afterSquares);
+      const gainedSquares = afterSquares.filter((target) => !beforeSet.has(target));
+      const lostSquares = beforeSquares.filter((target) => !afterSet.has(target));
+      if (gainedSquares.length || lostSquares.length) {
+        stationarySliderRays.push({
+          pieceId: id,
+          fromSquare: square,
+          color: piece.color,
+          pieceType: piece.type,
+          direction,
+          beforeSquares,
+          afterSquares,
+          gainedSquares,
+          lostSquares
+        });
+      }
+    }
+  }
+  const controlDelta = [];
+  for (const square of SQUARES2) {
+    for (const attackingColor of ["w", "b"]) {
+      const attackersBefore = attackers(before, square, attackingColor);
+      const attackersAfter = attackers(after, square, attackingColor);
+      if (attackersBefore.length !== attackersAfter.length || attackersBefore.some((origin, index) => origin !== attackersAfter[index])) {
+        controlDelta.push({ square, color: attackingColor, attackersBefore, attackersAfter });
+      }
+    }
+  }
+  return {
+    mover: {
+      pieceId: pieceId2,
+      pieceIdAfter,
+      fromSquare: from,
+      toSquare: to,
+      color,
+      pieceTypeBefore: moverBefore.type,
+      pieceTypeAfter: moverAfter.type,
+      attackersBefore: attackers(before, from, enemy(color)),
+      attackersAfter: attackers(after, to, enemy(color))
+    },
+    attackedUnmovedFriendlyPieces,
+    stationarySliderRays,
+    controlDelta,
+    checksRun: [
+      "mover-geometric-attackers-before-after",
+      "unmoved-friendly-piece-geometric-attackers-before-after",
+      "stationary-slider-visible-rays-before-after",
+      "all-square-both-color-geometric-control-delta"
+    ],
+    scope: "Complete board-local geometric measurements at this move. Attackers include pinned pieces; visible slider rays include the first occupied square. Empty lists mean measured none or no change. No claim of legal captures, safe retreat, exchange profit, forced purpose, or strategic importance."
+  };
+}
+
+// src/chess-reasoning/lossless-evidence-sharing.ts
+var EVIDENCE_SHARING_VERSION = "evidence-sharing/1";
+var EVIDENCE_SHARING_GUIDANCE_CHARS = 490;
+var object2 = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
+function shareEvidence(value) {
+  if (object2(value) && value.encoding === EVIDENCE_SHARING_VERSION) return value;
+  const counts = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new WeakMap();
+  let collision = false;
+  const count = (x) => {
+    if (!x || typeof x !== "object") return;
+    if (Object.hasOwn(x, "$shared")) collision = true;
+    const key = JSON.stringify(x);
+    keys.set(x, key);
+    if (key.length >= 96) counts.set(key, (counts.get(key) ?? 0) + 1);
+    for (const child of Object.values(x)) count(child);
+  };
+  count(value);
+  if (collision) return value;
+  const values = {}, ids = /* @__PURE__ */ new Map();
+  const children = (x) => Array.isArray(x) ? x.map(visit) : object2(x) ? Object.fromEntries(Object.entries(x).map(([k, v]) => [k, visit(v)])) : x;
+  const visit = (x) => {
+    if (!x || typeof x !== "object") return x;
+    const key = keys.get(x);
+    if ((counts.get(key) ?? 0) < 2) return children(x);
+    let id = ids.get(key);
+    if (!id) {
+      id = `s${ids.size}`;
+      ids.set(key, id);
+      values[id] = children(x);
+    }
+    return { $shared: id };
+  };
+  let content = children(value);
+  const stringCounts = /* @__PURE__ */ new Map();
+  const objectDefinitions = Object.entries(values);
+  const countStrings = (x) => {
+    if (typeof x === "string") {
+      stringCounts.set(x, (stringCounts.get(x) ?? 0) + 1);
+      return;
+    }
+    if (Array.isArray(x)) {
+      x.forEach(countStrings);
+      return;
+    }
+    if (object2(x) && !Object.hasOwn(x, "$shared")) Object.values(x).forEach(countStrings);
+  };
+  countStrings(content);
+  for (const [, definition] of objectDefinitions) countStrings(definition);
+  const stringIds = /* @__PURE__ */ new Map();
+  const shareStrings = (x) => {
+    if (typeof x === "string") {
+      const count2 = stringCounts.get(x) ?? 0;
+      let id = stringIds.get(x);
+      if (!id && count2 >= 2) {
+        const nextId = `s${ids.size + stringIds.size}`;
+        const literalLength = JSON.stringify(x).length;
+        const pointerLength = JSON.stringify({ $shared: nextId }).length;
+        const definitionLength = JSON.stringify(nextId).length + 1 + literalLength + 1;
+        if (count2 * literalLength > count2 * pointerLength + definitionLength) {
+          id = nextId;
+          stringIds.set(x, id);
+          values[id] = x;
+        }
+      }
+      return id ? { $shared: id } : x;
+    }
+    if (Array.isArray(x)) return x.map(shareStrings);
+    if (object2(x) && !Object.hasOwn(x, "$shared")) return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, shareStrings(v)]));
+    return x;
+  };
+  content = shareStrings(content);
+  for (const [id, definition] of objectDefinitions) values[id] = shareStrings(definition);
+  const result = { encoding: EVIDENCE_SHARING_VERSION, values, content };
+  return (ids.size || stringIds.size) && JSON.stringify(result).length + EVIDENCE_SHARING_GUIDANCE_CHARS + 128 < JSON.stringify(value).length ? result : value;
+}
+
+// test/owner/mechanism-encoding.test.mjs
+function measured(fen, uci) {
+  const before = new Chess3(fen);
+  const after = new Chess3(fen);
+  after.move({ from: uci.slice(0, 2), to: uci.slice(2, 4), promotion: uci.slice(4) || void 0 });
+  return moveMechanismFacts(before, after, uci.slice(0, 2), uci.slice(2, 4));
+}
+function oldProjection(value, targets) {
+  const controlSquares = [...new Set(targets)].filter((s) => /^[a-h][1-8]$/.test(s));
+  return {
+    ...value,
+    stationarySliderRays: value.stationarySliderRays.map((ray2) => {
+      const copy = { ...ray2 };
+      delete copy.beforeSquares;
+      delete copy.afterSquares;
+      return copy;
+    }),
+    controlDelta: value.controlDelta.filter((change) => controlSquares.includes(change.square)),
+    presentation: {
+      controlSquares,
+      omittedControlDeltaCount: value.controlDelta.length - value.controlDelta.filter((change) => controlSquares.includes(change.square)).length,
+      scope: "All changed stationary rays and mover/unmoved attack measurements retained. Control deltas shown only for controlSquares; an omitted square is not checked-negative in this view. Full ray extents and all control deltas are retrievable."
+    }
+  };
+}
+test("KE-REASON-016/021: row encoding round trips every currently projected field and omission marker", () => {
+  const examples = [
+    [measured("1k1r3r/2p5/p2p1p2/2P2B2/b3PB1p/5P2/3R2PP/2KR4 w - - 1 25", "d2b2"), ["d1", "b2", "d5"]],
+    [measured("r1bqkb1r/p1pp1pp1/1p3n1p/8/2BQP3/2N5/PPP2PPP/R1B1K2R w KQkq - 0 8", "e4e5"), ["e5", "g4", "f4", "e5"]],
+    [measured("8/4P3/1R2B3/6Bk/7P/8/8/2K5 w - - 3 50", "e6f7"), ["g4", "f7", "e8"]]
+  ];
+  for (const [full, targets] of examples) {
+    const compact = compactMechanism(full, targets);
+    assert.equal(compact.encoding, "move-mechanism/1");
+    assert.deepEqual(expandMechanismPresentation(compact), oldProjection(full, targets));
+    assert.deepEqual(compact.presentation.controlSquares, [...new Set(targets)]);
+    assert.ok(compact.columns.rays.includes("gainedSquares"));
+    assert.ok(compact.columns.control.includes("attackersAfter"));
+    assert.equal(expandMechanismPresentation(full), full);
+    assert.equal(compactMechanism(compact, targets), compact);
+  }
+});
+test("KE-REASON-016/021: unknown canonical fields fail open without information loss", () => {
+  const full = measured("r1bqkb1r/p1pp1pp1/1p3n1p/8/2BQP3/2N5/PPP2PPP/R1B1K2R w KQkq - 0 8", "e4e5");
+  for (const modified of [
+    { ...full, futureMeasurement: { value: 42 } },
+    { ...full, mover: { ...full.mover, futureIdentity: "some-id" } },
+    { ...full, stationarySliderRays: full.stationarySliderRays.map((ray2, index) => index ? ray2 : { ...ray2, futureRay: "retained" }) }
+  ]) {
+    const projected = compactMechanism(modified, ["g4"]);
+    assert.equal(projected.encoding, void 0);
+    assert.deepEqual(projected, oldProjection(modified, ["g4"]));
+  }
+  const encoded = compactMechanism(full, ["g4"]);
+  assert.equal(expandMechanismPresentation({ ...encoded, columns: { ...encoded.columns, rays: ["unknown"] } }).encoding, "move-mechanism/1");
+  assert.equal(expandMechanismPresentation({ ...encoded, rows: { ...encoded.rows, futureRows: [42] } }).encoding, "move-mechanism/1");
+});
+test("KE-REASON-016/021: row tables reduce repeated geometry bytes across a mixed search packet", () => {
+  const moves = [
+    "e2e4",
+    "e7e5",
+    "g1f3",
+    "b8c6",
+    "f1c4",
+    "h7h6",
+    "d2d4",
+    "e5d4",
+    "f3d4",
+    "c6d4",
+    "d1d4",
+    "g8f6",
+    "b1c3",
+    "b7b6",
+    "c3d5",
+    "f8c5"
+  ];
+  const board = new Chess3();
+  const baseline = [], encoded = [];
+  for (let index = 0; index < moves.length; index++) {
+    const uci = moves[index], before = new Chess3(board.fen());
+    board.move({ from: uci.slice(0, 2), to: uci.slice(2, 4) });
+    const fact = moveMechanismFacts(before, board, uci.slice(0, 2), uci.slice(2, 4));
+    const targets = [uci.slice(2, 4), moves[index + 1]?.slice(2, 4)].filter(Boolean);
+    baseline.push({ ply: index + 1, mechanism: oldProjection(fact, targets) });
+    encoded.push({ ply: index + 1, mechanism: compactMechanism(fact, targets) });
+  }
+  const originalBytes = JSON.stringify(shareEvidence(baseline)).length;
+  const encodedBytes = JSON.stringify(shareEvidence(encoded)).length;
+  assert.ok(encodedBytes < originalBytes * 0.75, `${originalBytes} -> ${encodedBytes}`);
+});