@crouton-kit/crouter 0.3.33 → 0.3.34

package/dist/core/__tests__/editor-label.test.js

@@ -1,26 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { editorLabel } from '../canvas/labels.js';
-function meta(over = {}) {
-    return {
-        node_id: 'n',
-        name: 'alpha-beta',
-        created: '2026-01-01T00:00:00.000Z',
-        cwd: '/tmp/work',
-        kind: 'developer',
-        mode: 'orchestrator',
-        lifecycle: 'resident',
-        status: 'active',
-        cycles: 7,
-        ...over,
-    };
-}
-test('editorLabel orders full name before kind and omits the cycle number', () => {
-    const label = editorLabel(meta());
-    assert.equal(label, 'alpha-beta developer (orchestrator)');
-    assert.equal(label.includes(String(meta().cycles)), false);
-});
-test('editorLabel falls back to kind when fullName collapses to kind or empty', () => {
-    assert.equal(editorLabel(meta({ name: 'developer', kind: 'developer', mode: 'base' })), 'developer (base)');
-    assert.equal(editorLabel(meta({ name: '', kind: 'developer', mode: 'base' })), 'developer (base)');
-});

package/dist/core/__tests__/fault-marker.test.js

@@ -1,112 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/fault-marker.test.ts
-//
-// BUG-REGRESSION: active-fault visibility. When a node's engine exhausts its
-// retry budget on a rate-limit / overloaded / connection error, the broker
-// stays alive and the node is indistinguishable from a healthy dormant node for
-// up to the fault retry quiet window.
-// The active-fault MARKER makes that invisible window visible on the canvas-graph
-// views. Two legs:
-//   M1 — classify: each kind + the fallback (the heuristic, order-sensitive:
-//        rate-limit/overloaded checked before connection).
-//   M2 — the marker round-trip through dashboardRowsAll: record → the row shows
-//        hanging (streaming forced false); clear → gone; a DEAD pid → not hanging
-//        (the pid-AND gate makes a stale marker from a crashed broker harmless).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { createHeadlessHarness } from './helpers/harness.js';
-import { classify } from '../fault-classifier.js';
-import { clearFault, recordFault, isModelNotFoundError } from '../runtime/fault.js';
-import { dashboardRowsAll } from '../canvas/render.js';
-// ---------------------------------------------------------------------------
-// M1 — the heuristic classifier.
-// ---------------------------------------------------------------------------
-test('M1 classify: each kind + fallback, order-sensitive', () => {
-    // rate-limit.
-    assert.equal(classify('pi→provider', 'Rate limit exceeded').kind, 'rate-limit');
-    assert.equal(classify('pi→provider', 'HTTP 429 Too Many Requests').kind, 'rate-limit');
-    assert.equal(classify('pi→provider', 'you have exceeded your quota').kind, 'rate-limit');
-    // overloaded.
-    assert.equal(classify('pi→provider', 'Overloaded').kind, 'overloaded');
-    assert.equal(classify('pi→provider', 'Error 529: server is temporarily unavailable').kind, 'overloaded');
-    assert.equal(classify('pi→provider', '503 Service Unavailable').kind, 'overloaded');
-    assert.equal(classify('pi→provider', 'the server busy, try again').kind, 'overloaded');
-    // connection.
-    assert.equal(classify('pi→provider', 'Connection error.').kind, 'connection');
-    assert.equal(classify('pi→provider', 'ECONNRESET').kind, 'connection');
-    assert.equal(classify('pi→provider', 'fetch failed').kind, 'connection');
-    assert.equal(classify('pi→provider', 'request timed out').kind, 'connection');
-    assert.equal(classify('viewer↔broker', { code: 'ENOENT' }).kind, 'connection');
-    assert.equal(classify('viewer↔broker', { code: 1011, reason: 'no running broker for n1' }).kind, 'connection');
-    // ORDER: a 429/529 whose text ALSO mentions connection/network must NOT be
-    // swallowed by the connection match (rate-limit/overloaded are checked first).
-    assert.equal(classify('pi→provider', '429 rate limit on this network connection').kind, 'rate-limit');
-    assert.equal(classify('pi→provider', '529 overloaded — connection to upstream lost').kind, 'overloaded');
-    // fallback.
-    assert.equal(classify('pi→provider', 'some unrecognized engine failure').kind, 'other');
-    assert.equal(classify('pi→provider', 'some unrecognized engine failure').disposition, 'fatal');
-    assert.equal(classify('pi→provider', '').kind, 'other');
-});
-// ---------------------------------------------------------------------------
-// BUG-REGRESSION: a 404 not_found (configured model decommissioned/unavailable)
-// must be detected so the broker fails the node over to the strong-anthropic
-// ladder model instead of wedging on the same dead model forever. The verbatim
-// text below is the engine error a node hit when its `anthropic/ultra` ladder
-// cell pointed at a model the account could not reach.
-// ---------------------------------------------------------------------------
-test('isModelNotFoundError detects the provider 404 not_found that triggers strong-anthropic fallback', () => {
-    const verbatim = 'Error: 404 {"type":"error","error":{"type":"not_found_error","message":"Claude Fable 5 is not available. Please use Opus 4.8. Learn more: https://www.anthropic.com/news/fable-mythos-access"},"request_id":"req_011CcHgqfwD2Hjg193Ym1Sys"}';
-    assert.equal(isModelNotFoundError(verbatim), true);
-    assert.equal(isModelNotFoundError('Error: 404 model not found'), true);
-    assert.equal(isModelNotFoundError('the requested model does not exist'), true);
-    assert.equal(isModelNotFoundError('HTTP 429 Too Many Requests'), false);
-    assert.equal(isModelNotFoundError('503 Service Unavailable'), false);
-    assert.equal(isModelNotFoundError('Connection error.'), false);
-    assert.equal(isModelNotFoundError('Error: 404 unexpected endpoint /v1/foo'), false);
-    assert.equal(isModelNotFoundError(''), false);
-});
-// ---------------------------------------------------------------------------
-// M2 — the marker round-trip through dashboardRowsAll.
-// ---------------------------------------------------------------------------
-test('M2 dashboardRowsAll surfaces a hanging marker (pid-gated); clear removes it', async () => {
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-esm' });
-    try {
-        // A LIVE node (the test process pid is definitely alive).
-        const liveId = h.fabricateBrokerNode({ kind: 'developer', status: 'active', pi_pid: process.pid });
-        // A node whose recorded pid is DEAD (the pid-gate must read it not-hanging).
-        // A child we spawn-then-let-exit gives a pid that is reliably gone.
-        const dead = spawnSync('true', [], { stdio: 'ignore' });
-        const deadPid = dead.pid ?? 2147483646; // `true` has already exited
-        const deadId = h.fabricateBrokerNode({ kind: 'developer', status: 'active', pi_pid: deadPid });
-        const find = (id) => dashboardRowsAll().find((r) => r.node_id === id);
-        // No marker yet → not hanging.
-        assert.equal(find(liveId)?.hanging ?? null, null, 'no marker → not hanging');
-        // Mark the live node → its row shows hanging, classified, streaming forced off.
-        recordFault(liveId, {
-            link: 'pi→provider',
-            op: 'generation turn',
-            kind: classify('pi→provider', 'Rate limit exceeded (429)').kind,
-            retry: { disposition: 'auto', by: 'daemon' },
-            message: 'Rate limit exceeded (429)',
-        });
-        const row = find(liveId);
-        assert.notEqual(row?.hanging ?? null, null, 'marked live node → hanging set');
-        assert.equal(row?.hanging?.kind, 'rate-limit', 'kind classified from the message');
-        assert.equal(row?.streaming, false, 'hanging forces streaming false (mutually exclusive)');
-        // A DEAD pid + a marker → NOT hanging (the pid-AND gate).
-        recordFault(deadId, {
-            link: 'pi→provider',
-            op: 'generation turn',
-            kind: classify('pi→provider', 'Connection error.').kind,
-            retry: { disposition: 'auto', by: 'daemon' },
-            message: 'Connection error.',
-        });
-        assert.equal(find(deadId)?.hanging ?? null, null, 'dead pid → marker ignored (pid gate)');
-        // Clear → gone.
-        clearFault(liveId);
-        assert.equal(find(liveId)?.hanging ?? null, null, 'cleared marker → not hanging');
-    }
-    finally {
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/fault-retry-rewind.test.d.ts

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

package/dist/core/__tests__/fault-retry-rewind.test.js

@@ -1,123 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/fault-retry-rewind.test.ts
-//
-// BUG-REGRESSION: broker-owned fault retries rewind the session tree before
-// re-sending the recovery nudge, so the active branch keeps exactly one nudge
-// and the first failed attempt stays on an abandoned sibling branch.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHeadlessHarness } from './helpers/harness.js';
-import { CONNECTION_FAULT_RECOVERY_BODY } from '../runtime/fault-recovery-nudge.js';
-const TASK = 'fault-retry rewind regression task';
-function messageText(message) {
-    if (typeof message.content === 'string')
-        return message.content;
-    const content = message.content ?? [];
-    for (const part of content) {
-        if (typeof part?.text === 'string' && part.text !== '')
-            return part.text;
-    }
-    return '';
-}
-function flatten(nodes) {
-    const out = [];
-    const walk = (node) => {
-        out.push(node);
-        for (const child of node.children)
-            walk(child);
-    };
-    for (const node of nodes)
-        walk(node);
-    return out;
-}
-function pathToLeaf(nodes, leafId) {
-    if (leafId === null)
-        return [];
-    const byId = new Map(nodes.map((node) => [node.entry.id, node]));
-    const path = [];
-    let cur = byId.get(leafId);
-    while (cur !== undefined) {
-        path.push(cur);
-        cur = cur.entry.parentId !== null ? byId.get(cur.entry.parentId) : undefined;
-    }
-    return path.reverse();
-}
-function readSnapshot(home, nodeId) {
-    const path = join(home, 'nodes', nodeId, 'fake-pi.tree.json');
-    return JSON.parse(readFileSync(path, 'utf8'));
-}
-function agentEndCount(home, nodeId) {
-    const path = join(home, 'nodes', nodeId, 'fake-pi.events.jsonl');
-    try {
-        return readFileSync(path, 'utf8')
-            .split('\n')
-            .filter((line) => line.trim() !== '')
-            .filter((line) => {
-            try {
-                return JSON.parse(line).event === 'agent_end';
-            }
-            catch {
-                return false;
-            }
-        }).length;
-    }
-    catch {
-        return 0;
-    }
-}
-test('broker fault retries rewind before replaying the recovery nudge', { timeout: 30_000 }, async () => {
-    const prevProbe = process.env['CRTR_FAULT_RETRY_PROBE'];
-    const prevFails = process.env['CRTR_FAKE_ENGINE_PROMPT_FAILS'];
-    process.env['CRTR_FAULT_RETRY_PROBE'] = 'always';
-    process.env['CRTR_FAKE_ENGINE_PROMPT_FAILS'] = '2';
-    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-fault-rewind' });
-    try {
-        const root = h.spawnRoot('fault-retry rewind root');
-        const nodeId = await h.spawnHeadlessChild(root, TASK);
-        await h.waitFor(() => (agentEndCount(h.home, nodeId) >= 2 ? true : null), { timeoutMs: 20_000, label: 'second failed attempt to settle' });
-        const snapshot = await h.waitFor(() => {
-            const fresh = readSnapshot(h.home, nodeId);
-            const flat = flatten(fresh.tree);
-            const path = pathToLeaf(flat, fresh.leafId);
-            const pathIds = new Set(path.map((node) => node.entry.id));
-            const nudgeOnPath = path.filter((node) => node.entry.message.role === 'user' && messageText(node.entry.message) === CONNECTION_FAULT_RECOVERY_BODY);
-            if (nudgeOnPath.length !== 1)
-                return null;
-            const nudgeNode = nudgeOnPath[0];
-            const failedAttempt = flat.find((node) => node.entry.message.role === 'assistant'
-                && node.entry.message.stopReason === 'error'
-                && messageText(node.entry.message) === TASK);
-            if (failedAttempt === undefined)
-                return null;
-            if (pathIds.has(failedAttempt.entry.id))
-                return null;
-            if (failedAttempt.entry.parentId !== nudgeNode.entry.parentId)
-                return null;
-            return fresh;
-        }, { timeoutMs: 20_000, label: 'rewound active branch snapshot' });
-        const flat = flatten(snapshot.tree);
-        const path = pathToLeaf(flat, snapshot.leafId);
-        const pathMessages = path.map((node) => node.entry.message);
-        assert.equal(pathMessages.filter((message) => message.role === 'user' && messageText(message) === CONNECTION_FAULT_RECOVERY_BODY).length, 1, 'the active branch carries exactly one recovery nudge');
-        const failedAttempt = flat.find((node) => node.entry.message.role === 'assistant'
-            && node.entry.message.stopReason === 'error'
-            && messageText(node.entry.message) === TASK);
-        assert.ok(failedAttempt !== undefined, 'the first failed attempt is still present in the tree');
-        assert.ok(!path.some((node) => node.entry.id === failedAttempt.entry.id), 'the first failed attempt is not on the active path');
-        const nudgeNode = path.find((node) => node.entry.message.role === 'user' && messageText(node.entry.message) === CONNECTION_FAULT_RECOVERY_BODY);
-        assert.ok(nudgeNode !== undefined, 'the active branch includes the recovery nudge');
-        assert.equal(failedAttempt.entry.parentId, nudgeNode.entry.parentId, 'the failed attempt is a sibling branch of the active nudge');
-    }
-    finally {
-        if (prevProbe === undefined)
-            delete process.env['CRTR_FAULT_RETRY_PROBE'];
-        else
-            process.env['CRTR_FAULT_RETRY_PROBE'] = prevProbe;
-        if (prevFails === undefined)
-            delete process.env['CRTR_FAKE_ENGINE_PROMPT_FAILS'];
-        else
-            process.env['CRTR_FAKE_ENGINE_PROMPT_FAILS'] = prevFails;
-        await h.dispose();
-    }
-});

package/dist/core/__tests__/frame-decoder-perf.test.d.ts

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

package/dist/core/__tests__/frame-decoder-perf.test.js

@@ -1,224 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/frame-decoder-perf.test.ts
-//
-// Bug-regression suite for the FrameDecoder O(n²) typing-lag bug (2026-06-09).
-//
-// OBSERVED BUG: typing in `crtr attach` lagged after the headless-broker change.
-// Root cause #1: FrameDecoder.push() did `this.buf += str` and re-scanned the
-// WHOLE accumulated buffer (`this.buf.indexOf('\n')` + Buffer.byteLength over
-// the consumed prefix) on every ~64 KiB socket chunk, so one large frame (the
-// multi-MiB `welcome` snapshot, a big tool result) cost O(frame × chunks) —
-// measured ~254 ms of event-loop stall decoding a 16 MiB frame, with the stall
-// growing ~5× per size doubling. The decoder runs on BOTH the viewer and broker
-// read paths, so the stall blocked keystroke handling directly.
-//
-// The fix holds the carried partial line as an array of chunk strings and scans
-// each incoming chunk exactly once — amortized O(total bytes). Same 16 MiB frame:
-// ~12 ms.
-//
-// These tests lock in (a) behavioral equivalence with the old decoder across
-// randomized chunkings — frames, blank-line skip, malformed-JSON drop, multibyte
-// splits, and both FrameOverflowError caps with identical byte accounting — and
-// (b) the linear growth curve via a SCALING-RATIO assertion (per-MiB decode cost
-// at 4 MiB vs 16 MiB must stay ~flat), so the quadratic shape cannot silently
-// return. The ratio is measured with min-of-reps and interleaved sizes so it is
-// robust to CPU contention from parallel `test:full` workers — see the perf test
-// for the full rationale.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { StringDecoder } from 'node:string_decoder';
-import { FrameDecoder, FrameOverflowError, CLIENT_READ_CAPS, } from '../runtime/broker-protocol.js';
-// ---------------------------------------------------------------------------
-// The PRE-FIX decoder, verbatim (git ed49e60), as the equivalence oracle.
-// ---------------------------------------------------------------------------
-class ReferenceFrameDecoder {
-    caps;
-    buf = '';
-    bufBytes = 0;
-    utf8 = new StringDecoder('utf8');
-    constructor(caps) {
-        this.caps = caps;
-    }
-    push(chunk) {
-        const str = typeof chunk === 'string' ? chunk : this.utf8.write(chunk);
-        this.buf += str;
-        this.bufBytes += Buffer.byteLength(str);
-        if (this.bufBytes > this.caps.maxTotalBytes) {
-            throw new FrameOverflowError('total', this.bufBytes, this.caps.maxTotalBytes);
-        }
-        const out = [];
-        let nl;
-        while ((nl = this.buf.indexOf('\n')) >= 0) {
-            const consumed = this.buf.slice(0, nl + 1);
-            this.bufBytes -= Buffer.byteLength(consumed);
-            const line = this.buf.slice(0, nl).trim();
-            this.buf = this.buf.slice(nl + 1);
-            if (line === '')
-                continue;
-            try {
-                out.push(JSON.parse(line));
-            }
-            catch {
-                /* drop malformed */
-            }
-        }
-        if (this.bufBytes > this.caps.maxLineBytes) {
-            throw new FrameOverflowError('line', this.bufBytes, this.caps.maxLineBytes);
-        }
-        return out;
-    }
-}
-// Deterministic PRNG so a failure reproduces.
-let seed = 0xc0ffee;
-const rnd = () => {
-    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
-    return seed / 0x7fffffff;
-};
-const randInt = (lo, hi) => lo + Math.floor(rnd() * (hi - lo + 1));
-const MULTIBYTE = ['é', '漢', '🎉', '𝕏', 'ü', '한'];
-const randText = (len) => {
-    let s = '';
-    while (s.length < len) {
-        s += rnd() < 0.2 ? MULTIBYTE[randInt(0, MULTIBYTE.length - 1)] : String.fromCharCode(randInt(97, 122));
-    }
-    return s;
-};
-function run(dec, stream, cuts) {
-    const frames = [];
-    let prev = 0;
-    try {
-        for (const cut of [...cuts, stream.length]) {
-            if (cut <= prev)
-                continue;
-            frames.push(...dec.push(stream.subarray(prev, cut)));
-            prev = cut;
-        }
-        return { frames, err: null };
-    }
-    catch (e) {
-        if (e instanceof FrameOverflowError)
-            return { frames, err: `${e.kind}:${e.bytes}:${e.cap}` };
-        throw e;
-    }
-}
-test('FrameDecoder — behavior-equivalent to the pre-fix decoder across randomized chunkings (frames, blank lines, malformed JSON, multibyte splits, both overflow caps)', () => {
-    for (let t = 0; t < 1500; t++) {
-        // Small caps in ~30% of trials exercise both FrameOverflowError kinds with
-        // identical byte accounting; generous caps exercise the happy path.
-        const caps = rnd() < 0.3
-            ? { maxLineBytes: randInt(50, 1500), maxTotalBytes: randInt(100, 4000) }
-            : { maxLineBytes: 1 << 20, maxTotalBytes: 1 << 21 };
-        const pieces = [];
-        for (let i = 0, n = randInt(1, 12); i < n; i++) {
-            const kind = rnd();
-            if (kind < 0.55)
-                pieces.push(JSON.stringify({ type: 'x', t: randText(randInt(0, 2000)) }) + '\n');
-            else if (kind < 0.7)
-                pieces.push('\n'); // blank-line skip
-            else if (kind < 0.8)
-                pieces.push('   \n'); // whitespace-only skip
-            else if (kind < 0.9)
-                pieces.push('{not json' + randText(randInt(0, 50)) + '\n'); // malformed drop
-            else
-                pieces.push(randText(randInt(0, 300))); // trailing partial, no newline
-        }
-        const stream = Buffer.from(pieces.join(''));
-        // Byte-level cut points — these can and do split multibyte chars.
-        const cuts = Array.from({ length: randInt(0, 20) }, () => randInt(0, stream.length)).sort((a, b) => a - b);
-        const expected = run(new ReferenceFrameDecoder(caps), stream, cuts);
-        const actual = run(new FrameDecoder(caps), stream, cuts);
-        assert.deepEqual(actual, expected, `trial ${t}: caps=${JSON.stringify(caps)} cuts=${JSON.stringify(cuts)} stream=${JSON.stringify(stream.toString('utf8').slice(0, 300))}`);
-    }
-});
-test('FrameDecoder — mixed string/Buffer pushes stay equivalent', () => {
-    for (let t = 0; t < 300; t++) {
-        const caps = { maxLineBytes: 1 << 20, maxTotalBytes: 1 << 21 };
-        const ref = new ReferenceFrameDecoder(caps);
-        const dec = new FrameDecoder(caps);
-        const refF = [];
-        const decF = [];
-        for (let i = 0, n = randInt(1, 10); i < n; i++) {
-            const s = rnd() < 0.5 ? JSON.stringify({ i, t: randText(randInt(0, 200)) }) + '\n' : randText(randInt(0, 100));
-            const input = rnd() < 0.5 ? s : Buffer.from(s);
-            refF.push(...ref.push(input));
-            decF.push(...dec.push(input));
-        }
-        assert.deepEqual(decF, refF, `mixed trial ${t}`);
-    }
-});
-test('FrameDecoder — a frame exactly AT each cap passes; one byte over throws (cap accounting exact)', () => {
-    // line cap: an unterminated partial exactly at maxLineBytes is fine…
-    {
-        const caps = { maxLineBytes: 100, maxTotalBytes: 1000 };
-        const dec = new FrameDecoder(caps);
-        assert.deepEqual(dec.push('x'.repeat(100)), []);
-        // …and the 101st byte trips it, reporting the full buffered size.
-        assert.throws(() => dec.push('x'), (e) => e instanceof FrameOverflowError && e.kind === 'line' && e.bytes === 101 && e.cap === 100);
-    }
-    // total cap: carry + chunk exactly at maxTotalBytes is fine; one over throws.
-    {
-        const caps = { maxLineBytes: 1000, maxTotalBytes: 100 };
-        const dec = new FrameDecoder(caps);
-        assert.deepEqual(dec.push('x'.repeat(60)), []);
-        assert.deepEqual(dec.push('x'.repeat(40 - 60 > 0 ? 0 : 40)), []); // 60 + 40 = 100, at cap
-        assert.throws(() => dec.push('x'), (e) => e instanceof FrameOverflowError && e.kind === 'total' && e.bytes === 101 && e.cap === 100);
-    }
-    // multibyte accounting: bytes, not chars (é = 2 bytes).
-    {
-        const caps = { maxLineBytes: 10, maxTotalBytes: 1000 };
-        const dec = new FrameDecoder(caps);
-        assert.throws(() => dec.push('é'.repeat(6)), // 12 bytes > 10, only 6 chars
-        (e) => e instanceof FrameOverflowError && e.kind === 'line' && e.bytes === 12);
-    }
-});
-test('FrameDecoder — large-frame decode is linear, not quadratic (the observed attach-lag regression)', () => {
-    // STRATEGY (contention-robust SCALING assertion): decode a single frame in
-    // 64 KiB socket-sized chunks at two sizes 4× apart (4 MiB vs 16 MiB) and assert
-    // the per-MiB cost stays ~flat. A linear decoder has per-MiB cost independent of
-    // size (ratio ≈ 1); the O(n²) bug makes per-MiB cost grow with size, so over a 4×
-    // size jump it grows ~4× (measured 5.5×+ pre-fix). Threshold 3× sits cleanly
-    // between the two signatures: well above linear noise, well below the quadratic
-    // signature.
-    //
-    // Why a RATIO, not an absolute wall-clock budget: an absolute budget is fragile
-    // under the parallel `test:full` workers — CPU contention scales every
-    // measurement up, so a tight budget flakes red on a loaded box without any code
-    // regression. A ratio of two contention-scaled measurements cancels whole-box
-    // slowdown, leaving only the algorithmic shape. Two further guards keep the
-    // minima clean under load: (1) MIN across REPS — contention only ADDS time, so
-    // the minimum approximates the uncontended cost; (2) the two sizes are timed
-    // INTERLEAVED within each rep, so a contention burst inflates both numerator and
-    // denominator alike instead of skewing the ratio. This fails ONLY on a
-    // complexity regression, not on a slow/busy CI box.
-    const CHUNK = 64 * 1024;
-    const SMALL_MIB = 4;
-    const LARGE_MIB = 16; // 4× SMALL — quadratic ⇒ per-MiB ~4×; linear ⇒ ~1×
-    const REPS = 7;
-    const makeFrame = (mib) => {
-        const overhead = Buffer.byteLength('{"type":"welcome","blob":""}\n');
-        return Buffer.from(`{"type":"welcome","blob":"${'x'.repeat(mib * 1024 * 1024 - overhead)}"}\n`);
-    };
-    const smallFrame = makeFrame(SMALL_MIB);
-    const largeFrame = makeFrame(LARGE_MIB);
-    const decodeMs = (frame) => {
-        const dec = new FrameDecoder(CLIENT_READ_CAPS);
-        const t0 = performance.now();
-        let n = 0;
-        for (let off = 0; off < frame.length; off += CHUNK) {
-            n += dec.push(frame.subarray(off, Math.min(off + CHUNK, frame.length))).length;
-        }
-        const ms = performance.now() - t0;
-        assert.equal(n, 1, 'decoded exactly one frame');
-        return ms;
-    };
-    decodeMs(smallFrame); // warm JIT on both paths before timing
-    decodeMs(largeFrame);
-    let bestSmall = Infinity;
-    let bestLarge = Infinity;
-    for (let rep = 0; rep < REPS; rep++) {
-        bestSmall = Math.min(bestSmall, decodeMs(smallFrame));
-        bestLarge = Math.min(bestLarge, decodeMs(largeFrame));
-    }
-    const perMibSmall = bestSmall / SMALL_MIB;
-    const perMibLarge = bestLarge / LARGE_MIB;
-    assert.ok(perMibLarge < perMibSmall * 3, `per-MiB decode cost grew superlinearly: ${perMibSmall.toFixed(2)}ms/MiB @${SMALL_MIB}MiB → ${perMibLarge.toFixed(2)}ms/MiB @${LARGE_MIB}MiB (ratio ${(perMibLarge / perMibSmall).toFixed(2)}×; quadratic regression)`);
-});

package/dist/core/__tests__/keystone.test.d.ts

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