squeezr-ai 1.81.1 → 1.90.0

package/bin/squeezr.js

@@ -5,7 +5,7 @@ import http from 'http'
 import path from 'path'
 import fs from 'fs'
 import os from 'os'
-import { fileURLToPath } from 'url'
+import { fileURLToPath, pathToFileURL } from 'url'
 import { createRequire } from 'module'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -250,8 +250,14 @@ Usage:
   squeezr gain             Show token savings stats
   squeezr gain --reset     Reset saved stats
   squeezr discover         Show pattern coverage report (proxy must be running)
+  squeezr learn            Mine Claude Code sessions for token-wasting loops
+  squeezr learn --apply    Write the learned rules to ./CLAUDE.local.md
+  squeezr bench            Run the compression + fact-recall benchmark
   squeezr status           Check if proxy is running
+  squeezr doctor           Diagnose proxy/version/routing/bypass (exit 0/1/2)
   squeezr config           Print config file path and current settings
+  squeezr rc [args...]     Launch 'claude --rc' (Remote Control) direct to api.anthropic.com
+                           (proxy bypassed for that session — Claude Code requires it)
   squeezr mcp install      Register Squeezr MCP server in Claude Code, Cursor, Windsurf & Cline
   squeezr mcp uninstall    Remove Squeezr MCP registration
   squeezr ports            Change HTTP and MITM proxy ports
@@ -284,6 +290,47 @@ function runNode(script, extraArgs = []) {
   child.on('exit', code => process.exit(code ?? 0))
 }
 
+// Launch Claude Code with Remote Control, bypassing the Squeezr proxy for THIS
+// session only. Claude Code refuses Remote Control unless it talks DIRECTLY to
+// api.anthropic.com — the binary guard is literally "Remote Control is only
+// available when using Claude via api.anthropic.com." Squeezr's terminal setup
+// exports ANTHROPIC_BASE_URL=http://localhost:<port>, which is not that host, so
+// `claude --rc` errors out. We strip that var (and the MITM CA) from the CHILD
+// env only. Global config is untouched: every other `claude` session still routes
+// through Squeezr and compresses normally. Trade-off: this remote session is not
+// compressed — remote sessions are short/interactive, so that's the right call.
+function claudeRc(extraArgs) {
+  const env = { ...process.env }
+  delete env.ANTHROPIC_BASE_URL
+  delete env.anthropic_base_url
+  delete env.NODE_EXTRA_CA_CERTS   // Squeezr's MITM CA — irrelevant talking direct
+
+  // Ensure --rc / --remote-control is present exactly once, then pass the rest through.
+  const rest = extraArgs.filter(a => a !== 'rc' && a !== 'remote-control')
+  const hasRc = rest.some(a => a === '--rc' || a === '--remote-control')
+  const claudeArgs = hasRc ? rest : ['--rc', ...rest]
+
+  console.log('Launching Claude Code with Remote Control — direct to api.anthropic.com')
+  console.log('(Squeezr proxy bypassed for THIS session only; global config untouched).\n')
+
+  // Never resolves — the child owns the terminal (stdio inherited) and we exit the
+  // wrapper with the child's code. Awaiting this blocks the trailing update banner
+  // from printing over Claude's interactive UI.
+  return new Promise(() => {
+    const child = spawn('claude', claudeArgs, {
+      stdio: 'inherit',
+      env,
+      shell: process.platform === 'win32',  // resolve claude.exe via PATH on Windows
+    })
+    child.on('exit', code => process.exit(code ?? 0))
+    child.on('error', err => {
+      console.error(`\nFailed to launch claude: ${err.message}`)
+      console.error('Is Claude Code installed and on your PATH? Try running `claude --version`.')
+      process.exit(1)
+    })
+  })
+}
+
 async function startDaemon() {
   const distIndex = path.join(ROOT, 'dist', 'index.js')
   if (!fs.existsSync(distIndex)) {
@@ -2504,6 +2551,11 @@ switch (command) {
     showConfig()
     break
 
+  case 'rc':
+  case 'remote-control':
+    await claudeRc(args.slice(1))
+    break
+
   case 'mcp': {
     const subCmd = args[1] ?? 'install'
     if (subCmd === 'uninstall') await mcpUninstall()
@@ -2514,6 +2566,35 @@ case 'zest':
     await installZest()
     break
 
+  case 'doctor': {
+    const { runDoctor } = await import(pathToFileURL(path.join(ROOT, 'dist', 'doctor.js')).href)
+    const res = await runDoctor()
+    console.log(res.report)
+    if (command !== 'update') await showUpdateBanner()
+    process.exit(res.exitCode)
+    break
+  }
+
+  case 'bench': {
+    const { runBench, formatBench } = await import(pathToFileURL(path.join(ROOT, 'dist', 'bench.js')).href)
+    console.log(formatBench(runBench()))
+    break
+  }
+
+  case 'learn': {
+    const apply = args.includes('--apply')
+    const tIdx = args.indexOf('--target')
+    const targetFile = tIdx >= 0 ? args[tIdx + 1] : undefined
+    const { runLearn } = await import(pathToFileURL(path.join(ROOT, 'dist', 'learn.js')).href)
+    const res = runLearn({ apply, targetFile })
+    console.log(res.report)
+    if (res.loops.length > 0) {
+      if (res.applied) console.log(`\nWrote ${res.loops.length} rule(s) to ${res.targetFile}`)
+      else console.log(`\nDry run. Re-run with --apply to write these rules to ${res.targetFile}.`)
+    }
+    break
+  }
+
   case 'version':
   case '--version':
   case '-v':

package/dist/__tests__/bench.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bench.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { factRecall, runBench, FIXTURES } from '../bench.js';
+describe('factRecall', () => {
+    it('returns 1 when every fact is present verbatim', () => {
+        expect(factRecall('error E123 in file foo.ts at line 42', ['E123', 'foo.ts', '42'])).toBe(1);
+    });
+    it('returns the fraction present', () => {
+        expect(factRecall('only E123 here', ['E123', 'MISSING'])).toBe(0.5);
+    });
+    it('returns 1 for an empty fact list (nothing to lose)', () => {
+        expect(factRecall('whatever', [])).toBe(1);
+    });
+});
+describe('FIXTURES', () => {
+    it('every fixture declares its critical facts', () => {
+        expect(FIXTURES.length).toBeGreaterThan(0);
+        for (const f of FIXTURES) {
+            expect(f.facts.length).toBeGreaterThan(0);
+            // sanity: the facts must actually be in the original content
+            for (const fact of f.facts)
+                expect(f.content.includes(fact)).toBe(true);
+        }
+    });
+});
+describe('runBench', () => {
+    it('produces a row per fixture with a valid shape', () => {
+        const summary = runBench();
+        expect(summary.rows.length).toBe(FIXTURES.length);
+        for (const r of summary.rows) {
+            expect(r.originalChars).toBeGreaterThan(0);
+            expect(r.compressedChars).toBeGreaterThan(0);
+            expect(r.compressionPct).toBeGreaterThanOrEqual(0);
+            expect(r.inlineRecall).toBeGreaterThanOrEqual(0);
+            expect(r.inlineRecall).toBeLessThanOrEqual(1);
+        }
+    });
+    it('achieves real compression on at least one fixture', () => {
+        const summary = runBench();
+        expect(summary.rows.some(r => r.compressionPct > 10)).toBe(true);
+    });
+    it('never drops a critical fact from the highly-compressible JSON fixture', () => {
+        // The homogeneous JSON array is crushed to a table — all VALUES must stay inline.
+        const summary = runBench();
+        const json = summary.rows.find(r => r.name.includes('json'));
+        expect(json).toBeDefined();
+        expect(json.compressionPct).toBeGreaterThan(10);
+        expect(json.inlineRecall).toBe(1);
+    });
+    it('reports honest averages', () => {
+        const summary = runBench();
+        expect(summary.avgCompressionPct).toBeGreaterThan(0);
+        expect(summary.avgInlineRecall).toBeGreaterThan(0);
+        expect(summary.avgInlineRecall).toBeLessThanOrEqual(1);
+    });
+});

package/dist/__tests__/cacheAligner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/cacheAligner.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { detectVolatile, analyzeSystemPrompt, formatVolatileWarning, _resetWarnedForTest, warnIfVolatile, } from '../cacheAligner.js';
+describe('detectVolatile', () => {
+    it('detects a UUID', () => {
+        const f = detectVolatile('session 550e8400-e29b-41d4-a716-446655440000 started');
+        expect(f.find(x => x.kind === 'uuid')?.count).toBe(1);
+    });
+    it('detects ISO timestamps', () => {
+        const f = detectVolatile('at 2026-07-21T10:00:00Z and 2026-07-21T11:00:00Z');
+        expect(f.find(x => x.kind === 'timestamp')?.count).toBe(2);
+    });
+    it('detects a JWT', () => {
+        const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+        const f = detectVolatile(`token=${jwt}`);
+        expect(f.find(x => x.kind === 'jwt')?.count).toBe(1);
+    });
+    it('detects long hex hashes', () => {
+        const sha = 'a'.repeat(64);
+        const f = detectVolatile(`commit ${sha}`);
+        expect(f.find(x => x.kind === 'hash')?.count).toBe(1);
+    });
+    it('returns nothing for clean stable text', () => {
+        expect(detectVolatile('You are a helpful coding assistant. Follow the rules.')).toEqual([]);
+    });
+    it('does not double-count a JWT as a hash', () => {
+        const jwt = 'eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+        const f = detectVolatile(jwt);
+        expect(f.find(x => x.kind === 'hash')).toBeUndefined();
+        expect(f.find(x => x.kind === 'jwt')?.count).toBe(1);
+    });
+});
+describe('analyzeSystemPrompt', () => {
+    it('handles a string system prompt', () => {
+        const r = analyzeSystemPrompt('build id 550e8400-e29b-41d4-a716-446655440000');
+        expect(r.hasVolatile).toBe(true);
+        expect(r.findings.length).toBeGreaterThan(0);
+    });
+    it('aggregates across an array of text blocks', () => {
+        const sys = [
+            { type: 'text', text: 'stable preamble' },
+            { type: 'text', text: 'ts 2026-07-21T10:00:00Z' },
+        ];
+        const r = analyzeSystemPrompt(sys);
+        expect(r.findings.find(f => f.kind === 'timestamp')?.count).toBe(1);
+    });
+    it('reports clean when there is nothing volatile', () => {
+        const r = analyzeSystemPrompt('You are Claude, a coding assistant.');
+        expect(r.hasVolatile).toBe(false);
+        expect(r.findings).toEqual([]);
+    });
+    it('ignores non-text blocks and undefined', () => {
+        expect(analyzeSystemPrompt(undefined).hasVolatile).toBe(false);
+        const sys = [{ type: 'image', source: {} }, { type: 'text', text: 'clean' }];
+        expect(analyzeSystemPrompt(sys).hasVolatile).toBe(false);
+    });
+});
+describe('formatVolatileWarning', () => {
+    it('mentions each detected kind', () => {
+        const msg = formatVolatileWarning([{ kind: 'uuid', count: 2 }, { kind: 'timestamp', count: 1 }]);
+        expect(msg.includes('uuid')).toBe(true);
+        expect(msg.includes('timestamp')).toBe(true);
+    });
+});
+describe('warnIfVolatile', () => {
+    it('warns once per distinct finding signature (no per-request spam)', () => {
+        _resetWarnedForTest();
+        const sys = 'id 550e8400-e29b-41d4-a716-446655440000';
+        expect(warnIfVolatile(sys)).toBe(true); // first time → warns
+        expect(warnIfVolatile(sys)).toBe(false); // same signature → suppressed
+    });
+    it('does not warn on clean prompts', () => {
+        _resetWarnedForTest();
+        expect(warnIfVolatile('perfectly stable system prompt')).toBe(false);
+    });
+});

package/dist/__tests__/codeStructure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/codeStructure.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { detectCodeLanguage, extractCodeStructure } from '../deterministic.js';
+import { retrieveOriginal } from '../expand.js';
+describe('detectCodeLanguage', () => {
+    it('detects the existing languages', () => {
+        expect(detectCodeLanguage("import x from 'y'\nexport function f(): void {}")).toBe('ts');
+        expect(detectCodeLanguage('from os import path\ndef f():\n    pass')).toBe('py');
+        expect(detectCodeLanguage('package main\nfunc main() {}')).toBe('go');
+        expect(detectCodeLanguage('use std::io;\npub fn main() {}')).toBe('rs');
+    });
+    it('detects Java', () => {
+        const java = 'package com.acme.app;\nimport java.util.List;\npublic class Service {\n  public void run() {}\n}';
+        expect(detectCodeLanguage(java)).toBe('java');
+    });
+    it('detects C++ (has std::/class/namespace)', () => {
+        const cpp = '#include <vector>\n#include <string>\nnamespace app {\nclass Widget {\n  void draw() {}\n};\n}';
+        expect(detectCodeLanguage(cpp)).toBe('cpp');
+    });
+    it('detects C (includes, no C++ markers)', () => {
+        const c = '#include <stdio.h>\n#include <stdlib.h>\nint main(int argc, char **argv) {\n  return 0;\n}';
+        expect(detectCodeLanguage(c)).toBe('c');
+    });
+    it('returns null for non-code prose', () => {
+        expect(detectCodeLanguage('This is a plain english log line.\nAnother sentence here.')).toBeNull();
+    });
+});
+describe('extractCodeStructure — Java', () => {
+    function bigJava() {
+        const lines = ['package com.acme;', 'import java.util.List;', '', 'public class Orders {'];
+        for (let m = 0; m < 6; m++) {
+            lines.push(`  public int method${m}(int a, int b) {`);
+            for (let b = 0; b < 15; b++)
+                lines.push(`    int local${b} = a + b + ${m};`);
+            lines.push('    return a;');
+            lines.push('  }');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    it('keeps signatures, elides bodies, and stays smaller', () => {
+        const input = bigJava();
+        const out = extractCodeStructure(input, 'java');
+        expect(out).not.toBe(input);
+        expect(out.length).toBeLessThan(input.length);
+        // signatures survive
+        expect(out.includes('public int method0(int a, int b)')).toBe(true);
+        expect(out.includes('public class Orders')).toBe(true);
+        // an omitted-lines marker is present
+        expect(/implementation lines omitted|lines omitted/.test(out)).toBe(true);
+    });
+    it('is fully recoverable via the parent expand id', () => {
+        const input = bigJava();
+        const out = extractCodeStructure(input, 'java');
+        const m = out.match(/squeezr_expand\("([0-9a-f]{6,})"\)/);
+        expect(m).not.toBeNull();
+        expect(retrieveOriginal(m[1])).toBe(input);
+    });
+});
+describe('extractCodeStructure — C++', () => {
+    it('keeps class + method signatures', () => {
+        const lines = ['#include <vector>', '', 'class Engine {', 'public:'];
+        for (let m = 0; m < 5; m++) {
+            lines.push(`  void step${m}(double dt) {`);
+            for (let b = 0; b < 12; b++)
+                lines.push(`    acc += dt * ${b};`);
+            lines.push('  }');
+        }
+        lines.push('};');
+        const input = lines.join('\n');
+        const out = extractCodeStructure(input, 'cpp');
+        expect(out.includes('void step0(double dt)')).toBe(true);
+        expect(out.length).toBeLessThan(input.length);
+    });
+});

package/dist/__tests__/deterministic.test.js

@@ -105,6 +105,19 @@ describe('preprocess - base pipeline', () => {
         const input = 'a\nb\na';
         expect(preprocess(input)).toBe('a\nb\na');
     });
+    // Regression (1.82.0): repeated bare object keys like `body:` were folded into
+    // "... [repeated N more times]", which corrupted code when it round-tripped to disk.
+    it('never folds repeated bare object keys (body:)', () => {
+        // Mirrors the real incident: identical keys, unique values on the next line.
+        const input = Array.from({ length: 5 }, (_, i) => `    body:\n      "unique text ${i}",`).join('\n');
+        const out = preprocess(input);
+        expect(out).not.toContain('repeated');
+        expect(out.split('\n').filter(l => l.trim() === 'body:')).toHaveLength(5);
+    });
+    it('still folds genuine repeated log prose (colon with a value after)', () => {
+        const input = Array(5).fill('ERROR: connection refused').join('\n');
+        expect(preprocess(input)).toContain('repeated 4 more times');
+    });
     it('minifies inline JSON blobs > 200 chars', () => {
         const obj = Object.fromEntries(Array.from({ length: 20 }, (_, i) => [`key_${i}`, `value_number_${i}`]));
         const pretty = JSON.stringify(obj, null, 2);

package/dist/__tests__/doctor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/doctor.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { checkProxy, checkVersion, checkEnv, checkBypass, computeExitCode, formatDoctor, } from '../doctor.js';
+describe('checkProxy', () => {
+    it('passes when health is present', () => {
+        expect(checkProxy({ identity: 'squeezr', version: '1.89.0' }).status).toBe('pass');
+    });
+    it('fails when the proxy is unreachable', () => {
+        expect(checkProxy(null).status).toBe('fail');
+    });
+});
+describe('checkVersion', () => {
+    it('passes when installed matches running', () => {
+        expect(checkVersion('1.89.0', '1.89.0').status).toBe('pass');
+    });
+    it('warns on a stale running proxy', () => {
+        const r = checkVersion('1.89.0', '1.88.0');
+        expect(r.status).toBe('warn');
+        expect(r.detail.includes('1.88.0')).toBe(true);
+    });
+    it('skips when the running version is unknown (proxy down)', () => {
+        expect(checkVersion('1.89.0', null).status).toBe('skip');
+    });
+});
+describe('checkEnv', () => {
+    it('passes when ANTHROPIC_BASE_URL points at the local proxy', () => {
+        expect(checkEnv('http://localhost:8080', 8080).status).toBe('pass');
+        expect(checkEnv('http://127.0.0.1:8080', 8080).status).toBe('pass');
+    });
+    it('warns when unset (traffic not routed through squeezr)', () => {
+        expect(checkEnv(undefined, 8080).status).toBe('warn');
+        expect(checkEnv('', 8080).status).toBe('warn');
+    });
+    it('fails when it points somewhere else', () => {
+        expect(checkEnv('https://api.anthropic.com', 8080).status).toBe('fail');
+        expect(checkEnv('http://localhost:9999', 8080).status).toBe('fail');
+    });
+});
+describe('checkBypass', () => {
+    it('warns when bypass is on (compression disabled)', () => {
+        expect(checkBypass(true).status).toBe('warn');
+    });
+    it('passes when bypass is off', () => {
+        expect(checkBypass(false).status).toBe('pass');
+    });
+    it('skips when unknown', () => {
+        expect(checkBypass(undefined).status).toBe('skip');
+    });
+});
+describe('computeExitCode', () => {
+    it('0 when all pass/skip', () => {
+        expect(computeExitCode([{ name: 'a', status: 'pass', detail: '' }, { name: 'b', status: 'skip', detail: '' }])).toBe(0);
+    });
+    it('1 when there is a warning but no failure', () => {
+        expect(computeExitCode([{ name: 'a', status: 'pass', detail: '' }, { name: 'b', status: 'warn', detail: '' }])).toBe(1);
+    });
+    it('2 when there is any failure', () => {
+        expect(computeExitCode([{ name: 'a', status: 'warn', detail: '' }, { name: 'b', status: 'fail', detail: '' }])).toBe(2);
+    });
+});
+describe('formatDoctor', () => {
+    it('renders every check line and a summary', () => {
+        const out = formatDoctor([
+            { name: 'Proxy', status: 'pass', detail: 'running v1.89.0' },
+            { name: 'Env', status: 'warn', detail: 'not set' },
+        ], 1);
+        expect(out.includes('Proxy')).toBe(true);
+        expect(out.includes('Env')).toBe(true);
+        expect(out.toLowerCase().includes('warn')).toBe(true);
+    });
+});

package/dist/__tests__/jsonCrush.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/jsonCrush.test.js

@@ -0,0 +1,110 @@
+import { describe, it, expect } from 'vitest';
+import { crushJsonArrays, TABLE_MARKER_RE } from '../jsonCrush.js';
+import { retrieveOriginal } from '../expand.js';
+function makeRows(n) {
+    const rows = [];
+    for (let i = 0; i < n; i++) {
+        rows.push({ id: i, name: `service-${i}`, status: i % 2 === 0 ? 'running' : 'stopped', region: 'us-east-1' });
+    }
+    return JSON.stringify(rows);
+}
+describe('crushJsonArrays', () => {
+    it('crushes a uniform array of >=5 objects and saves chars', () => {
+        const input = makeRows(20);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        expect(text.length).toBeLessThan(input.length);
+        expect(TABLE_MARKER_RE.test(text)).toBe(true);
+    });
+    it('embeds a recoverable squeezr_expand id that returns the ORIGINAL json', () => {
+        const input = makeRows(20);
+        const { text } = crushJsonArrays(input);
+        const m = text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        const id = m[1];
+        expect(retrieveOriginal(id)).toBe(input);
+    });
+    it('keeps every value present in the table body (lossless representation)', () => {
+        const input = makeRows(6);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('service-0')).toBe(true);
+        expect(text.includes('service-5')).toBe(true);
+        expect(text.includes('running')).toBe(true);
+        expect(text.includes('stopped')).toBe(true);
+    });
+    it('lists the column names once in the header, not per row', () => {
+        const input = makeRows(10);
+        const { text } = crushJsonArrays(input);
+        // "region" appears once as a column header, never repeated as a JSON key
+        expect((text.match(/"region"/g) ?? []).length).toBe(0);
+        expect(text.includes('region')).toBe(true);
+    });
+    it('does NOT crush arrays below the minimum item count', () => {
+        const input = JSON.stringify([{ a: 1 }, { a: 2 }]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush a single JSON object', () => {
+        const input = JSON.stringify({ id: 1, name: 'x', status: 'ok', region: 'eu' });
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush an array of scalars (no keys to factor out)', () => {
+        const input = JSON.stringify([1, 2, 3, 4, 5, 6, 7, 8]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('leaves non-JSON text unchanged', () => {
+        const input = 'this is just a log line\nand another one';
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('does NOT crush when the columnar form would not save enough', () => {
+        // few rows, tiny keys → little repeated-key overhead → not worth it
+        const input = JSON.stringify([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }]);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBe(0);
+        expect(text).toBe(input);
+    });
+    it('handles heterogeneous objects (missing keys) and stays recoverable', () => {
+        const arr = [
+            { id: 1, name: 'a', status: 'ok', extra: 'z' },
+            { id: 2, name: 'b', status: 'ok' },
+            { id: 3, name: 'c', status: 'fail', region: 'eu' },
+            { id: 4, name: 'd', status: 'ok' },
+            { id: 5, name: 'e', status: 'ok' },
+            { id: 6, name: 'f', status: 'ok' },
+        ];
+        const input = JSON.stringify(arr);
+        const { text } = crushJsonArrays(input);
+        const m = text.match(TABLE_MARKER_RE);
+        expect(m).not.toBeNull();
+        expect(retrieveOriginal(m[1])).toBe(input);
+    });
+    it('renders nested objects inline as compact JSON', () => {
+        const arr = Array.from({ length: 6 }, (_, i) => ({
+            id: i,
+            meta: { region: 'us', tier: 'gold' },
+            name: `n${i}`,
+        }));
+        const input = JSON.stringify(arr);
+        const { text } = crushJsonArrays(input);
+        expect(text.includes('{"region":"us","tier":"gold"}')).toBe(true);
+    });
+    it('is deterministic — same input yields byte-identical output (cache-safe)', () => {
+        const input = makeRows(15);
+        const a = crushJsonArrays(input).text;
+        const b = crushJsonArrays(input).text;
+        expect(a).toBe(b);
+    });
+    it('crushes a pretty-printed (indented) JSON array too', () => {
+        const input = JSON.stringify(Array.from({ length: 8 }, (_, i) => ({ id: i, name: `x${i}`, status: 'ok', region: 'us' })), null, 2);
+        const { text, savedChars } = crushJsonArrays(input);
+        expect(savedChars).toBeGreaterThan(0);
+        expect(TABLE_MARKER_RE.test(text)).toBe(true);
+    });
+});

package/dist/__tests__/learn.test.d.ts

@@ -0,0 +1 @@
+export {};