@elaraai/east-node-cli 1.0.79 → 1.0.80

package/dist/runner.spec.js

@@ -14,10 +14,9 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { ArrayType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, East, SortedMap, SortedSet, compareFor, decodeBeast2For, encodeBeast2For, encodeBeast2PagedFor, toEastTypeValue, encodeEastIR, none, openBeast2PagesFor, some, spliceBeast2, } from '@elaraai/east';
+import { ArrayType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, Beast2ManifestWriter, East, SortedMap, SortedSet, UnitType, compareFor, decodeBeast2For, decodeCollectionManifest, encodeBeast2For, encodeBeast2PagedFor, encodeBeast2SegmentsFor, toEastTypeValue, encodeEastIR, none, openBeast2PagesFor, some, spliceBeast2, variant, } from '@elaraai/east';
 import { runProgram, lazyThreshold } from './runner.js';
 import { mergeBlobs } from './merge.js';
-import { EmitFileWriter } from './emit-writer.js';
 /** Runs `run` with console.error captured; returns what it printed. */
 async function stderrOf(run) {
     const lines = [];
@@ -31,6 +30,20 @@ async function stderrOf(run) {
     }
     return lines.join('\n');
 }
+/** Runs `run` with the lazy-open threshold set to `bytes`. */
+async function withLazyThreshold(bytes, run) {
+    const saved = process.env.EAST_LAZY_INPUT_BYTES;
+    process.env.EAST_LAZY_INPUT_BYTES = String(bytes);
+    try {
+        return await run();
+    }
+    finally {
+        if (saved === undefined)
+            delete process.env.EAST_LAZY_INPUT_BYTES;
+        else
+            process.env.EAST_LAZY_INPUT_BYTES = saved;
+    }
+}
 /** `promise`'s value, or `undefined` once `ms` pass first — a bounded wait. */
 async function within(promise, ms) {
     let timer;
@@ -59,14 +72,15 @@ describe('runner output encoding', () => {
         return new Uint8Array(readFileSync(outputPath));
     }
     it('writes large collection outputs segmented and indexed', async () => {
-        const output = await runToOutput(2500n);
+        const output = await runToOutput(20000n);
         const AT = ArrayType(IntegerType);
         const pages = openBeast2PagesFor(AT)(output);
-        assert.equal(pages.segmentCount, 3);
-        assert.equal(pages.elementCount, 2500);
+        assert.ok(pages.segmentCount > 1);
+        assert.equal(pages.elementCount, 20_000);
         assert.ok(pages.selfContained);
-        const expected = Array.from({ length: 2500 }, (_, i) => BigInt(i));
-        assert.deepEqual(pages.slice(900, 200), expected.slice(900, 1100), 'window spans segments');
+        const expected = Array.from({ length: 20_000 }, (_, i) => BigInt(i));
+        const edge = pages.counts[0];
+        assert.deepEqual(pages.slice(edge - 100, 200), expected.slice(edge - 100, edge + 100), 'window spans segments');
         assert.deepEqual(decodeBeast2For(AT)(output), expected, 'whole decode equals the result');
     });
     it('writes small collection outputs segmented and indexed too', async () => {
@@ -80,10 +94,10 @@ describe('runner output encoding', () => {
         assert.deepEqual(decodeBeast2For(AT)(output), expected, 'whole decode equals the result');
     });
 });
-describe('runner streaming execution', () => {
+describe('lazy inputs', () => {
     let tempDir;
     beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'east-node-stream-'));
+        tempDir = mkdtempSync(join(tmpdir(), 'east-node-lazy-'));
     });
     afterEach(() => {
         rmSync(tempDir, { recursive: true, force: true });
@@ -93,86 +107,16 @@ describe('runner streaming execution', () => {
         writeFileSync(irPath, encodeEastIR(fn.toIR()));
         return irPath;
     }
-    it('a producer body emits an indexed Array output incrementally', async () => {
-        const fn = East.function([FunctionType([IntegerType], NullType)], NullType, ($, emit) => {
-            $.for(East.Array.range(0n, 2500n), ($, i) => {
-                $(emit(i.multiply(2n)));
-            });
-        });
-        const outputPath = join(tempDir, 'output.beast2');
-        await runProgram(writeIr(fn), [], [], [], outputPath, { emit: 'array' });
-        const output = new Uint8Array(readFileSync(outputPath));
-        const pages = openBeast2PagesFor(ArrayType(IntegerType))(output);
-        assert.equal(pages.elementCount, 2500);
-        assert.ok(pages.selfContained);
-        assert.equal(pages.element(1234), 2468n);
-        const expected = Array.from({ length: 2500 }, (_, i) => BigInt(i * 2));
-        assert.deepEqual(decodeBeast2For(ArrayType(IntegerType))(output), expected);
-    });
-    it('a stream input folds through emit with the input opened lazily', async () => {
-        const AT = ArrayType(IntegerType);
-        const events = Array.from({ length: 2500 }, (_, i) => BigInt(i));
-        const inputPath = join(tempDir, 'events.beast2');
-        writeFileSync(inputPath, encodeBeast2PagedFor(AT, { batchSize: 500 })(events));
-        const fn = East.function([AT, FunctionType([IntegerType], NullType)], NullType, ($, events, emit) => {
-            const acc = $.let(0n);
-            $.for(events, ($, v) => {
-                $.assign(acc, acc.add(v));
-                $(emit(acc));
-            });
-        });
-        const outputPath = join(tempDir, 'output.beast2');
-        await runProgram(writeIr(fn), [], [], [inputPath], outputPath, { emit: 'array', streamInputs: [0] });
-        const decoded = decodeBeast2For(AT)(new Uint8Array(readFileSync(outputPath)));
-        assert.equal(decoded.length, 2500);
-        assert.equal(decoded[0], 0n);
-        assert.equal(decoded[2499], (2499n * 2500n) / 2n);
-    });
-    /** A dict producer emitting `row-${i}` for each key in the given order. */
-    function dictEmitter(order) {
-        const emitType = FunctionType([IntegerType, StringType], NullType);
-        return East.function([emitType], NullType, ($, emit) => {
-            $.for($.const(order, ArrayType(IntegerType)), ($, i) => {
-                $(emit(i, East.str `row-${i}`));
-            });
-        });
-    }
-    it('an ascending dict emit writes the canonical blob, segmented and indexed', async () => {
-        const outputPath = join(tempDir, 'ordered.beast2');
-        const ascending = Array.from({ length: 1000 }, (_, i) => BigInt(i));
-        await runProgram(writeIr(dictEmitter(ascending)), [], [], [], outputPath, { emit: 'dict' });
-        const output = new Uint8Array(readFileSync(outputPath));
-        const DT = DictType(IntegerType, StringType);
-        const decoded = decodeBeast2For(DT)(output);
-        assert.equal(decoded.size, 1000);
-        assert.equal(decoded.get(42n), 'row-42');
-        assert.ok(openBeast2PagesFor(DT)(output).selfContained);
-    });
-    it('a dict emit rejects an out-of-order key with the ascending contract\'s error (#770)', async () => {
-        // Set/Dict emissions must ascend in East order: the sink writes one pass
-        // and never buffers, so a key below the previous one is the error — in
-        // the same words on every runner — and nothing is reported on stderr on
-        // the way there.
-        const err = await stderrOf(() => assert.rejects(runProgram(writeIr(dictEmitter([2n, 1n])), [], [], [], join(tempDir, 'disorder.beast2'), { emit: 'dict' }), { message: 'beast2 v5: Dict key emitted out of order: 1 after 2 — Set/Dict emissions must ascend in East order' }));
-        assert.equal(err, '');
-    });
-    it('a duplicate dict key is a hard error', async () => {
-        const emitType = FunctionType([IntegerType, StringType], NullType);
-        const adjacent = East.function([emitType], NullType, ($, emit) => {
-            $(emit(1n, 'a'));
-            $(emit(1n, 'b'));
-        });
-        await assert.rejects(runProgram(writeIr(adjacent), [], [], [], join(tempDir, 'dup.beast2'), { emit: 'dict' }), { message: 'beast2 v5: duplicate Dict key emitted: 1 — Dict keys must be unique' });
-    });
     it('a lazy dict input serves keyed reads without a whole decode', async () => {
         const DT = DictType(IntegerType, StringType);
         const table = new SortedMap(Array.from({ length: 2000 }, (_, i) => [BigInt(i), `row-${i}`]), compareFor(IntegerType));
         const inputPath = join(tempDir, 'table.beast2');
-        writeFileSync(inputPath, encodeBeast2PagedFor(DT, { batchSize: 250 })(table));
+        const entries = [...table];
+        writeFileSync(inputPath, encodeBeast2SegmentsFor(DT)(Array.from({ length: 8 }, (_, i) => new Map(entries.slice(i * 250, (i + 1) * 250)))));
         const fn = East.function([DT], StringType, ($, table) => table.get(1234n));
         const outputPath = join(tempDir, 'output.beast2');
         // Threshold of 1 byte forces the lazy open for any input size.
-        await runProgram(writeIr(fn), [], [], [inputPath], outputPath, { lazyInputBytes: 1 });
+        await withLazyThreshold(1, () => runProgram(writeIr(fn), [], [], [inputPath], outputPath));
         const result = decodeBeast2For(StringType)(new Uint8Array(readFileSync(outputPath)));
         assert.equal(result, 'row-1234');
     });
@@ -180,19 +124,12 @@ describe('runner streaming execution', () => {
         const DT = DictType(IntegerType, StringType);
         const table = new SortedMap(Array.from({ length: 500 }, (_, i) => [BigInt(i), `row-${i}`]), compareFor(IntegerType));
         const inputPath = join(tempDir, 'table.beast2');
-        writeFileSync(inputPath, encodeBeast2PagedFor(DT, { batchSize: 100 })(table));
+        const entries = [...table];
+        writeFileSync(inputPath, encodeBeast2SegmentsFor(DT)(Array.from({ length: 5 }, (_, i) => new Map(entries.slice(i * 100, (i + 1) * 100)))));
         const fn = East.function([DT], StringType, ($, table) => table.get(42n));
         const outputPath = join(tempDir, 'output.beast2');
-        const lines = [];
-        const original = console.error;
-        console.error = (...args) => { lines.push(args.map(String).join(' ')); };
-        try {
-            await runProgram(writeIr(fn), [], [], [inputPath], outputPath, { lazyInputBytes: 1, verbose: true });
-        }
-        finally {
-            console.error = original;
-        }
-        assert.ok(lines.some((l) => l.includes('input 0: opened lazily')), `verbose output names the lazy input:\n${lines.join('\n')}`);
+        const err = await stderrOf(() => withLazyThreshold(1, () => runProgram(writeIr(fn), [], [], [inputPath], outputPath, true)));
+        assert.ok(err.includes('input 0: opened lazily'), `verbose output names the lazy input:\n${err}`);
         assert.equal(decodeBeast2For(StringType)(new Uint8Array(readFileSync(outputPath))), 'row-42');
     });
     it('a lazily opened wide input reads a fraction of the file and stays below the eager run\'s residency', { skip: process.platform === 'win32' ? 'no RSS comparison on Windows' : false }, () => {
@@ -242,40 +179,11 @@ describe('runner streaming execution', () => {
         assert.ok(lazy !== null && eager !== null, 'the runner reports its RSS');
         assert.ok(lazy < eager, `lazy peak ${lazy} MB not below eager peak ${eager} MB for a ${wireMb.toFixed(1)} MB input`);
     });
-    it('refuses --emit with a non-.beast2 output, like east-c and east-py', async () => {
-        const fn = East.function([FunctionType([IntegerType], NullType)], NullType, ($, emit) => {
-            $(emit(1n));
-        });
-        await assert.rejects(runProgram(writeIr(fn), [], [], [], join(tempDir, 'out.json'), { emit: 'array' }), /--emit requires a \.beast2 output file \(-o\)/);
-    });
-    it('refuses --emit on a zero-parameter function with the emit-capability error', async () => {
-        // The one sentence east-c and east-py give for the same shape — a
-        // zero-parameter function has no trailing parameter to be the capability,
-        // and so does one whose trailing parameter is not a function.
-        const message = "--emit requires the function's trailing parameter to be the emit capability (a function type)";
-        await assert.rejects(runProgram(writeIr(East.function([], IntegerType, (_$) => 1n)), [], [], [], join(tempDir, 'out.beast2'), { emit: 'array' }), { message });
-        await assert.rejects(runProgram(writeIr(East.function([IntegerType], IntegerType, (_$, n) => n)), [], [], [], join(tempDir, 'out.beast2'), { emit: 'array' }), { message });
-    });
-    it('a set emit rejects an out-of-order element and names duplicates with the element noun', async () => {
-        const emitType = FunctionType([IntegerType], NullType);
-        const disordered = East.function([emitType], NullType, ($, emit) => {
-            $(emit(2n));
-            $(emit(1n));
-            $(emit(3n));
-        });
-        await assert.rejects(runProgram(writeIr(disordered), [], [], [], join(tempDir, 'set.beast2'), { emit: 'set' }), { message: 'beast2 v5: Set element emitted out of order: 1 after 2 — Set/Dict emissions must ascend in East order' });
-        const dup = East.function([emitType], NullType, ($, emit) => {
-            $(emit(1n));
-            $(emit(2n));
-            $(emit(2n));
-        });
-        await assert.rejects(runProgram(writeIr(dup), [], [], [], join(tempDir, 'dupset.beast2'), { emit: 'set' }), { message: 'beast2 v5: duplicate Set element emitted: 2 — Set elements must be unique' });
-    });
 });
-describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
+describe('the blob merge and the stdin lifeline (#770)', () => {
     let tempDir;
     beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'east-node-fold-'));
+        tempDir = mkdtempSync(join(tmpdir(), 'east-node-merge-'));
     });
     afterEach(() => {
         rmSync(tempDir, { recursive: true, force: true });
@@ -285,119 +193,64 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
         writeFileSync(irPath, encodeEastIR(fn.toIR()));
         return irPath;
     }
-    const PairType = StructType({ key: IntegerType, value: StringType });
-    const emitPairType = FunctionType([IntegerType, StringType], NullType);
     const emitKeyType = FunctionType([IntegerType], NullType);
-    const ascendingBigints = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
     const DT = DictType(IntegerType, StringType);
     const ST = SetType(IntegerType);
-    /** The fold contract's emission sequence, as keys — the sequence
-     *  generate_fixtures.mjs writes for east-c and east-py: 0..1199 in order
-     *  with adjacent duplicates, every third key twice, and key 999 — the last
-     *  entry of a full 1000-element batch — four times. */
-    function foldSequence() {
-        const keys = [];
-        for (let k = 0; k < 1200; k++) {
-            const copies = 1 + (k % 3 === 0 ? 1 : 0) + (k % 1000 === 999 ? 2 : 0);
-            for (let c = 0; c < copies; c++)
-                keys.push(BigInt(k));
-        }
-        return keys;
-    }
-    /** A dict producer emitting the given (key, value) pairs in order. */
-    function pairEmitter(pairs) {
-        return East.function([emitPairType], NullType, ($, emit) => {
-            $.for($.const(pairs, ArrayType(PairType)), ($, pair) => {
-                $(emit(pair.key, pair.value));
-            });
-        });
-    }
-    /** A set producer emitting the given keys in order. */
-    function keyEmitter(keys) {
-        return East.function([emitKeyType], NullType, ($, emit) => {
-            $.for($.const(keys, ArrayType(IntegerType)), ($, key) => {
-                $(emit(key));
-            });
-        });
-    }
     /** The concatenating `(Integer, String, String) -> String` fold. */
     function writeConcat() {
         return writeIr('merge.beast2', East.function([IntegerType, StringType, StringType], StringType, (_$, _key, acc, value) => acc.concat(value)));
     }
-    it('--merge writes the folded ascending sequence\'s bytes', async () => {
-        // The fold is over ADJACENT equal keys, and lands in place — key 999
-        // into a full batch's last entry included — so the output is
-        // byte-identical to what the flag-less sink writes for the folded
-        // sequence.
-        const pairs = foldSequence().map((key, i) => ({ key, value: `${i};` }));
-        const folded = new Map();
-        for (const { key, value } of pairs)
-            folded.set(key, (folded.get(key) ?? '') + value);
-        const foldedPairs = [...folded].sort(([a], [b]) => ascendingBigints(a, b)).map(([key, value]) => ({ key, value }));
-        const expectedPath = join(tempDir, 'expected.beast2');
-        await runProgram(writeIr('folded.beast2', pairEmitter(foldedPairs)), [], [], [], expectedPath, { emit: 'dict' });
-        const outputPath = join(tempDir, 'output.beast2');
-        await runProgram(writeIr('program.beast2', pairEmitter(pairs)), [], [], [], outputPath, { emit: 'dict', merge: writeConcat() });
-        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), new Uint8Array(readFileSync(expectedPath)), 'the folded output must be byte-identical to the flag-less sink\'s output for the folded sequence');
-    });
-    it('--union writes the ascending sequence\'s distinct keys\' bytes', async () => {
-        const keys = foldSequence();
-        const distinct = [...new Set(keys)].sort(ascendingBigints);
-        const expectedPath = join(tempDir, 'expected.beast2');
-        await runProgram(writeIr('folded.beast2', keyEmitter(distinct)), [], [], [], expectedPath, { emit: 'set' });
-        const outputPath = join(tempDir, 'output.beast2');
-        await runProgram(writeIr('program.beast2', keyEmitter(keys)), [], [], [], outputPath, { emit: 'set', union: true });
-        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), new Uint8Array(readFileSync(expectedPath)), 'the union output must be byte-identical to the flag-less sink\'s output for the distinct keys');
-    });
-    it('a fold does not admit an out-of-order key', async () => {
-        const pairs = [{ key: 2n, value: 'a' }, { key: 1n, value: 'b' }];
-        await assert.rejects(runProgram(writeIr('program.beast2', pairEmitter(pairs)), [], [], [], join(tempDir, 'output.beast2'), { emit: 'dict', merge: writeConcat() }), { message: 'beast2 v5: Dict key emitted out of order: 1 after 2 — Set/Dict emissions must ascend in East order' });
-    });
     // ---- The blob merge ---------------------------------------------------
     /** Three sorted Dict inputs whose keys overlap — a = 0..19, b = 10..29,
-     *  c = {5, 15, 25, 40} — each value naming its input, written by the paged
-     *  writer in four-entry segments; the fixtures east-c and east-py merge. */
+     *  c = {5, 15, 25, 40} — each value naming its input, written in four-entry
+     *  segments. */
     const mergeKeys = {
         a: Array.from({ length: 20 }, (_, k) => BigInt(k)),
         b: Array.from({ length: 20 }, (_, k) => BigInt(k + 10)),
         c: [5n, 15n, 25n, 40n],
     };
+    /** Ascending entries as a blob of four-entry segments: a geometry chosen
+     *  here rather than by the cut rule, so a range bound can fall inside a
+     *  segment, on a fence, and between segments. */
+    function inFours(type, entries) {
+        const batches = [];
+        for (let i = 0; i < entries.length; i += 4) {
+            const chunk = entries.slice(i, i + 4);
+            batches.push(type.type === 'Dict' ? new Map(chunk) : new Set(chunk));
+        }
+        return encodeBeast2SegmentsFor(toEastTypeValue(type))(batches);
+    }
     function writeDictInput(name) {
         const path = join(tempDir, `in_${name}.beast2`);
-        writeFileSync(path, encodeBeast2PagedFor(DT, { batchSize: 4 })(new SortedMap(mergeKeys[name].map((k) => [k, `${name}${k}`]), compareFor(IntegerType))));
+        writeFileSync(path, inFours(DT, mergeKeys[name].map((k) => [k, `${name}${k}`])));
         return path;
     }
     function writeSetInput(name) {
         const path = join(tempDir, `set_${name}.beast2`);
-        writeFileSync(path, encodeBeast2PagedFor(ST, { batchSize: 4 })(new SortedSet(mergeKeys[name], compareFor(IntegerType))));
+        writeFileSync(path, inFours(ST, mergeKeys[name]));
         return path;
     }
-    it('merge writes the fold of overlapping dict inputs byte-identical to the ascending sink', async () => {
-        const folded = new Map();
+    it('merge writes the fold of overlapping dict inputs as the Writer writes the folded value', () => {
+        const folded = new SortedMap([], compareFor(IntegerType));
         for (const name of ['a', 'b', 'c']) {
             for (const k of mergeKeys[name])
                 folded.set(k, (folded.get(k) ?? '') + `${name}${k}`);
         }
-        const foldedPairs = [...folded].sort(([a], [b]) => ascendingBigints(a, b)).map(([key, value]) => ({ key, value }));
-        const expectedPath = join(tempDir, 'expected.beast2');
-        await runProgram(writeIr('folded.beast2', pairEmitter(foldedPairs)), [], [], [], expectedPath, { emit: 'dict' });
         const outputPath = join(tempDir, 'merged.beast2');
         const inputs = [writeDictInput('a'), writeDictInput('b'), writeDictInput('c')];
         const stats = mergeBlobs(inputs, outputPath, { mergePath: writeConcat() });
         assert.deepEqual(stats, { inputs: 3, entries: 31, folds: 13 });
-        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), new Uint8Array(readFileSync(expectedPath)), 'the merge must write exactly what the sink writes for the folded sequence emitted ascending');
+        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), encodeBeast2PagedFor(DT)(folded), 'the merge must write exactly what the Writer writes for the folded value');
         const table = decodeBeast2For(DT)(new Uint8Array(readFileSync(outputPath)));
         assert.equal(table.get(15n), 'a15b15c15');
         assert.equal(table.get(40n), 'c40');
     });
-    it('merge --union writes the distinct elements of set inputs byte-identical to the ascending sink', async () => {
-        const distinct = [...new Set([...mergeKeys.a, ...mergeKeys.b, ...mergeKeys.c])].sort(ascendingBigints);
-        const expectedPath = join(tempDir, 'expected.beast2');
-        await runProgram(writeIr('folded.beast2', keyEmitter(distinct)), [], [], [], expectedPath, { emit: 'set' });
+    it('a union merge writes the distinct elements of set inputs as the Writer writes them', () => {
+        const distinct = new SortedSet([...mergeKeys.a, ...mergeKeys.b, ...mergeKeys.c], compareFor(IntegerType));
         const outputPath = join(tempDir, 'union.beast2');
         const stats = mergeBlobs([writeSetInput('a'), writeSetInput('b'), writeSetInput('c')], outputPath, { union: true });
         assert.deepEqual(stats, { inputs: 3, entries: 31, folds: 13 });
-        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), new Uint8Array(readFileSync(expectedPath)));
+        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), encodeBeast2PagedFor(ST)(distinct));
         assert.equal(openBeast2PagesFor(ST)(new Uint8Array(readFileSync(outputPath))).elementCount, 31);
     });
     it('merge without a fold refuses a shared key and leaves the output unfinalised', () => {
@@ -416,8 +269,8 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
         // error, prefixed with the input — the same sentence east-c and east-py give.
         const descending = join(tempDir, 'descending.beast2');
         writeFileSync(descending, spliceBeast2([
-            encodeBeast2PagedFor(DT, { batchSize: 2 })(new SortedMap([[1000n, 'x'], [1001n, 'y']], compareFor(IntegerType))),
-            encodeBeast2PagedFor(DT, { batchSize: 2 })(new SortedMap([[1n, 'a'], [2n, 'b']], compareFor(IntegerType))),
+            encodeBeast2PagedFor(DT)(new SortedMap([[1000n, 'x'], [1001n, 'y']], compareFor(IntegerType))),
+            encodeBeast2PagedFor(DT)(new SortedMap([[1n, 'a'], [2n, 'b']], compareFor(IntegerType))),
         ]));
         assert.throws(() => mergeBlobs([descending], join(tempDir, 'desc.beast2')), { message: `merge: input 0 (${descending}): beast2 v5: Dict keys are not strictly ascending in East order — the wire must hold the canonical value (corrupt or pre-contract blob)` });
         const missing = join(tempDir, 'missing.beast2');
@@ -441,10 +294,10 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
     });
     it('merge names a fold of the wrong signature and refuses a fold of the wrong kind', () => {
         const wrong = writeIr('wrong.beast2', East.function([StringType, StringType, StringType], StringType, (_$, _key, acc, value) => acc.concat(value)));
-        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'w.beast2'), { mergePath: wrong }), (err) => err.message.startsWith('--merge: expected a function (K, V, V) -> V matching the inputs (K = '));
-        assert.throws(() => mergeBlobs([writeSetInput('a')], join(tempDir, 'ms.beast2'), { mergePath: writeConcat() }), { message: '--merge applies to Dict inputs only' });
-        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'ud.beast2'), { union: true }), { message: '--union applies to Set inputs only' });
-        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'both.beast2'), { mergePath: writeConcat(), union: true }), { message: 'merge: --merge and --union are two folds — give one' });
+        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'w.beast2'), { mergePath: wrong }), (err) => err.message.startsWith('merge function: expected a function (K, V, V) -> V matching the inputs (K = '));
+        assert.throws(() => mergeBlobs([writeSetInput('a')], join(tempDir, 'ms.beast2'), { mergePath: writeConcat() }), { message: 'merge: a merge function applies to Dict inputs only' });
+        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'ud.beast2'), { union: true }), { message: 'merge: union applies to Set inputs only' });
+        assert.throws(() => mergeBlobs([writeDictInput('a')], join(tempDir, 'both.beast2'), { mergePath: writeConcat(), union: true }), { message: 'merge: a merge function and union are two folds — give one' });
     });
     it('an empty input contributes nothing, and a lone empty input yields the empty collection, indexed', () => {
         const empty = join(tempDir, 'empty.beast2');
@@ -460,7 +313,7 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
         assert.equal(openBeast2PagesFor(DT)(new Uint8Array(readFileSync(emptyOut))).elementCount, 0);
     });
     // ---- Key ranges ---------------------------------------------------------
-    /** A `--range` blob over Integer keys: `[from, to)`, a `null` bound open. */
+    /** A range blob over Integer keys: `[from, to)`, a `null` bound open. */
     const RangeT = StructType({ from: OptionType(IntegerType), to: OptionType(IntegerType) });
     function writeRange(name, from, to) {
         const path = join(tempDir, `range_${name}.beast2`);
@@ -472,15 +325,15 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
     /** An input holding only its keys in the range — the sliced twin a ranged merge must equal. */
     function writeDictSlice(name, from, to) {
         const path = join(tempDir, `in_${name}_${from}_${to}.beast2`);
-        writeFileSync(path, encodeBeast2PagedFor(DT, { batchSize: 4 })(new SortedMap(mergeKeys[name].filter((k) => inRange(k, from, to)).map((k) => [k, `${name}${k}`]), compareFor(IntegerType))));
+        writeFileSync(path, inFours(DT, mergeKeys[name].filter((k) => inRange(k, from, to)).map((k) => [k, `${name}${k}`])));
         return path;
     }
     function writeSetSlice(name, from, to) {
         const path = join(tempDir, `set_${name}_${from}_${to}.beast2`);
-        writeFileSync(path, encodeBeast2PagedFor(ST, { batchSize: 4 })(new SortedSet(mergeKeys[name].filter((k) => inRange(k, from, to)), compareFor(IntegerType))));
+        writeFileSync(path, inFours(ST, mergeKeys[name].filter((k) => inRange(k, from, to))));
         return path;
     }
-    it('merge --range writes the keys in [from, to) byte-identical to merging inputs that hold only those keys', () => {
+    it('a ranged merge writes the keys in [from, to) byte-identical to merging inputs that hold only those keys', () => {
         // The inputs are written in four-entry segments, so the bounds fall
         // inside segments, on a fence, before the first key, past the last,
         // and one range holds nothing.
@@ -512,134 +365,110 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
         assert.equal(openBeast2PagesFor(DT)(new Uint8Array(readFileSync(join(tempDir, 'ranged_7_22.beast2')))).elementCount, 15);
         assert.equal(openBeast2PagesFor(DT)(new Uint8Array(readFileSync(join(tempDir, 'ranged_30_39.beast2')))).elementCount, 0, 'a range holding nothing writes the empty collection, indexed');
     });
-    it('merge --range refuses bounds of another key type, a missing file, an empty file and a file that is not a blob', () => {
+    it('a ranged merge refuses bounds of another key type, a missing file, an empty file and a file that is not a blob', () => {
         const inputs = [writeDictInput('a'), writeDictInput('b')];
         const mismatch = join(tempDir, 'range_mismatch.beast2');
         writeFileSync(mismatch, encodeBeast2For(StructType({ from: OptionType(StringType), to: OptionType(StringType) }))({ from: none, to: none }));
-        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm.beast2'), { mergePath: writeConcat(), rangePath: mismatch }), (err) => err.message.startsWith(`merge: --range (${mismatch}) has type `) && err.message.endsWith(" (bounds over the inputs' key type)"));
+        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm.beast2'), { mergePath: writeConcat(), rangePath: mismatch }), (err) => err.message.startsWith(`merge: range (${mismatch}) has type `) && err.message.endsWith(" (bounds over the inputs' key type)"));
         const missing = join(tempDir, 'range_missing.beast2');
-        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm2.beast2'), { mergePath: writeConcat(), rangePath: missing }), { message: `merge: --range (${missing}): cannot open the file` });
+        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm2.beast2'), { mergePath: writeConcat(), rangePath: missing }), { message: `merge: range (${missing}): cannot open the file` });
         // Not a blob: the reader's own words, as east-c and east-py say them.
         const text = join(tempDir, 'range_text.beast2');
         writeFileSync(text, 'not a blob');
-        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm3.beast2'), { mergePath: writeConcat(), rangePath: text }), { message: `merge: --range (${text}): Invalid Beast2 magic at offset 0: expected 0x89, got 0x6e` });
+        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm3.beast2'), { mergePath: writeConcat(), rangePath: text }), { message: `merge: range (${text}): Invalid Beast2 magic at offset 0: expected 0x89, got 0x6e` });
         const empty = join(tempDir, 'range_empty.beast2');
         writeFileSync(empty, '');
-        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm4.beast2'), { mergePath: writeConcat(), rangePath: empty }), { message: `merge: --range (${empty}): Data too short for Beast2 format: 0 bytes` });
-    });
-    it('the merge command prints its account, takes a range and refuses two folds', () => {
-        const bin = fileURLToPath(new URL('../bin/east-node.mjs', import.meta.url));
-        const outputPath = join(tempDir, 'cli-merged.beast2');
-        const inputs = [writeDictInput('a'), writeDictInput('b'), writeDictInput('c')];
-        const result = spawnSync(process.execPath, [bin, 'merge', '--merge', writeConcat(), ...inputs.flatMap((p) => ['-i', p]), '-o', outputPath, '-v'], { encoding: 'utf8' });
-        assert.equal(result.status, 0, result.stderr);
-        assert.ok(result.stderr.includes('merge: 3 input(s), 31 entries, 13 fold(s)'), result.stderr);
-        assert.equal(openBeast2PagesFor(DT)(new Uint8Array(readFileSync(outputPath))).elementCount, 31);
-        const rangedPath = join(tempDir, 'cli-ranged.beast2');
-        const ranged = spawnSync(process.execPath, [bin, 'merge', '--merge', writeConcat(), '--range', writeRange('cli', 7n, 22n), ...inputs.flatMap((p) => ['-i', p]), '-o', rangedPath, '-v'], { encoding: 'utf8' });
-        assert.equal(ranged.status, 0, ranged.stderr);
-        assert.ok(ranged.stderr.includes('merge: 3 input(s), 15 entries, 11 fold(s)'), ranged.stderr);
-        const both = spawnSync(process.execPath, [bin, 'merge', '--merge', writeConcat(), '--union', '-i', inputs[0], '-o', join(tempDir, 'both.beast2')], { encoding: 'utf8' });
-        assert.equal(both.status, 1);
-        assert.ok(both.stderr.includes('Error: --merge and --union are two folds — give one'), both.stderr);
-    });
-    it('the emit writer segments a value exactly as the paged encoder does', () => {
-        // One value segments the same wherever it is written (#770): a task that
-        // RETURNS a collection writes it through encodeBeast2PagedFor, one that
-        // emits or merges writes it through this writer, and a content-addressed
-        // store must see one blob. The writer opened at the element cap where the
-        // encoder probes its first entries, so rows above a segment's share got
-        // one oversized first segment and every later boundary shifted.
-        //
-        // Incompressible rows, from a deterministic LCG: deflate shrinks anything
-        // patterned back under the byte target, and then every batch is the cap
-        // and the two agree no matter what.
-        let seed = 12345;
-        const noise = (chars) => {
-            const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-            let out = '';
-            for (let i = 0; i < chars; i++) {
-                seed = (seed * 48271) % 2147483647;
-                out += alphabet[(seed >> 8) & 63];
-            }
-            return out;
-        };
-        for (const width of [4_000, 200_000]) {
-            seed = 12345;
-            const rows = Array.from({ length: 60 }, (_, i) => [BigInt(i), noise(width)]);
-            const value = new SortedMap(rows, compareFor(IntegerType));
-            const paged = encodeBeast2PagedFor(DT)(value);
-            const path = join(tempDir, `segments-${width}.beast2`);
-            const writer = new EmitFileWriter('dict', toEastTypeValue(DT), path);
-            for (const [key, text] of rows)
-                writer.push([key, text]);
-            writer.finishClose();
-            assert.deepEqual(new Uint8Array(readFileSync(path)), paged, `a ${width}-char row segments the same emitted as returned`);
+        assert.throws(() => mergeBlobs(inputs, join(tempDir, 'rm4.beast2'), { mergePath: writeConcat(), rangePath: empty }), { message: `merge: range (${empty}): Data too short for Beast2 format: 0 bytes` });
+    });
+    it('merge reads manifest directories, the form e3 stages a stored collection in, as east-c and east-py do', () => {
+        // Each input twice over: a blob, and a manifest directory — the manifest's
+        // file and, beside it in `<file>.segments/`, each object named by its
+        // SHA-256. Enough keys for several segments, so a range seeks through the
+        // manifest's fences.
+        const inputs = [0, 2000].map((start) => Array.from({ length: 3000 }, (_, k) => [BigInt(start + k), `v${start + k}`]));
+        const blobs = inputs.map((entries, i) => {
+            const path = join(tempDir, `wide_${i}.beast2`);
+            writeFileSync(path, encodeBeast2PagedFor(DT)(new SortedMap(entries, compareFor(IntegerType))));
+            return path;
+        });
+        const manifests = inputs.map((entries, i) => {
+            const path = join(tempDir, `wide_${i}.manifest.beast2`);
+            const dir = `${path}.segments`;
+            mkdirSync(dir);
+            const writer = new Beast2ManifestWriter(DT, {
+                object: (hash, bytes) => writeFileSync(join(dir, `${hash}.beast2`), bytes),
+                manifest: (bytes) => writeFileSync(path, bytes),
+            });
+            for (const entry of entries)
+                writer.add(entry);
+            writer.finish();
+            return path;
+        });
+        assert.ok(decodeCollectionManifest(new Uint8Array(readFileSync(manifests[0]))).entries.length > 1, 'several segments');
+        for (const rangePath of [undefined, writeRange('manifest', 1500n, 2600n)]) {
+            const options = { mergePath: writeConcat(), ...(rangePath !== undefined && { rangePath }) };
+            const fromBlobs = join(tempDir, 'from-blobs.beast2');
+            const fromManifests = join(tempDir, 'from-manifests.beast2');
+            assert.deepEqual(mergeBlobs([manifests[0], blobs[1]], fromManifests, options), mergeBlobs(blobs, fromBlobs, options));
+            assert.deepEqual(new Uint8Array(readFileSync(fromManifests)), new Uint8Array(readFileSync(fromBlobs)));
         }
-    });
-    it('a container two entries share stays one NEW and one REF', () => {
-        // The writer scopes beast2 aliasing per SEGMENT, so a container two
-        // entries of one segment share is written once and referenced. A merge
-        // of such an input alone must write its bytes back exactly, because the
-        // merge writes through the same writer `run --emit` does. east-c encoded
-        // each entry under its own scope and wrote the shared value twice — a
-        // bigger blob and a different hash for one value, and the two runners
-        // disagreeing; the same fixture is `merge_aliased.beast2` in east-c's
-        // and east-py's suites.
-        const VT = StructType({ tags: ArrayType(StringType) });
+        // A segment gone from the directory is named when the merge reaches it,
+        // in east-c's words.
+        const gone = `${manifests[1]}.segments/${decodeCollectionManifest(new Uint8Array(readFileSync(manifests[1]))).entries[0].hash}.beast2`;
+        rmSync(gone);
+        assert.throws(() => mergeBlobs([blobs[0], manifests[1]], join(tempDir, 'broken.beast2'), { mergePath: writeConcat() }), { message: `merge: input 1 (${manifests[1]}): beast2 v5: manifest segment ${gone} cannot be read` });
+    });
+    it('a container two entries share is written for each, and an older blob merges to that form', () => {
+        // The writer scopes beast2 aliasing per root ELEMENT, so a container two
+        // entries share is written out in each: the bytes depend on the entries'
+        // content alone. A merge of such an input writes its bytes back exactly,
+        // because the merge writes through the canonical writer. A blob an older
+        // writer left — aliasing scoped per segment, the second entry a REF —
+        // still reads, and merges to the same canonical bytes.
+        const TagsT = DictType(IntegerType, StructType({ tags: ArrayType(StringType) }));
         const shared = ['x', 'y', 'zzzzzzzzzzzzzzzzzzzz'];
+        const value = new SortedMap([[1n, { tags: shared }], [2n, { tags: shared }]], compareFor(IntegerType));
+        const canonical = encodeBeast2PagedFor(TagsT)(value);
         const inputPath = join(tempDir, 'aliased.beast2');
-        writeFileSync(inputPath, encodeBeast2PagedFor(DictType(IntegerType, VT), { batchSize: 10 })(new SortedMap([[1n, { tags: shared }], [2n, { tags: shared }]], compareFor(IntegerType))));
+        writeFileSync(inputPath, canonical);
         const outputPath = join(tempDir, 'aliased-merged.beast2');
         assert.deepEqual(mergeBlobs([inputPath], outputPath), { inputs: 1, entries: 2, folds: 0 });
-        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), new Uint8Array(readFileSync(inputPath)));
-    });
-    it('the merge command refuses its arguments in the other runners\' words', () => {
-        // One sentence per condition, identical on east-c, east-node and east-py:
-        // the three runners are interchangeable, so a task that names one of them
-        // must fail the same way on any of them. One line, no JS stack — a
-        // refusal of the command line is the user's error, not the program's.
-        const bin = fileURLToPath(new URL('../bin/east-node.mjs', import.meta.url));
-        const out = join(tempDir, 'args.beast2');
-        const input = writeDictInput('a');
-        const cases = [
-            [[], 'Error: merge requires at least one -i input'],
-            [['-o', out], 'Error: merge requires at least one -i input'],
-            [['-i', input], 'Error: merge requires -o FILE'],
-            [['-i', input, '-o', out, '--merge', writeConcat(), '--union'],
-                'Error: --merge and --union are two folds — give one'],
-            [['-i', input, '-o', join(tempDir, 'args.bin')],
-                'Error: merge requires a .beast2 output file (-o)'],
-        ];
-        for (const [args, message] of cases) {
-            const result = spawnSync(process.execPath, [bin, 'merge', ...args], { encoding: 'utf8' });
-            assert.equal(result.status, 1, result.stderr);
-            assert.deepEqual(result.stderr.trimEnd().split('\n'), [message]);
-        }
+        assert.deepEqual(new Uint8Array(readFileSync(outputPath)), canonical);
+        // The older writer's bytes: one segment aliased across its entries — what
+        // a writer without self-containment writes — flagged self-contained, as
+        // that writer flagged every blob.
+        const legacy = encodeBeast2SegmentsFor(TagsT, { selfContained: false })([value]);
+        const view = new DataView(legacy.buffer, legacy.byteOffset, legacy.byteLength);
+        legacy[Number(view.getBigUint64(legacy.length - 16, true))] = 0x01;
+        assert.notDeepEqual(legacy, canonical, 'the older bytes hold a REF the canonical ones do not');
+        const legacyPath = join(tempDir, 'aliased-legacy.beast2');
+        writeFileSync(legacyPath, legacy);
+        const legacyOut = join(tempDir, 'aliased-legacy-merged.beast2');
+        assert.deepEqual(mergeBlobs([legacyPath], legacyOut), { inputs: 1, entries: 2, folds: 0 });
+        assert.deepEqual(new Uint8Array(readFileSync(legacyOut)), canonical);
     });
     it('a repeated flag takes one value, so it never swallows the ir file', () => {
-        // `--stream <index...>` (and `-i`/`-p` variadic) ate the positional that
-        // followed, so `run --stream 0 program.beast2` reported its IR file
-        // missing — while east-c and east-py, whose flags take one value and
-        // repeat, accepted the same line. Every runner README documents the
-        // repeated form.
+        // A variadic flag ate the positional that followed it, so a run that
+        // named its IR file after one reported the file missing — while east-c
+        // and east-py, whose flags take one value and repeat, accepted the same
+        // line. Every runner README documents the repeated form.
         const bin = fileURLToPath(new URL('../bin/east-node.mjs', import.meta.url));
-        const irPath = writeIr('streamed.beast2', pairEmitter([{ key: 1n, value: 'a' }]));
+        const inputPath = join(tempDir, 'n.beast2');
+        writeFileSync(inputPath, encodeBeast2For(IntegerType)(20n));
+        const irPath = writeIr('double.beast2', East.function([IntegerType], IntegerType, ($, n) => n.multiply(2n)));
         const stdDir = fileURLToPath(new URL('../../east-node-std', import.meta.url));
-        const result = spawnSync(process.execPath, [bin, 'run', '--stream', '0', irPath, '-p', '@elaraai/east-node-std',
-            '--emit', 'dict', '-o', join(tempDir, 'streamed-out.beast2')], { env: { ...process.env, E3_RUNNER_SEARCH_DIRS: stdDir }, encoding: 'utf8' });
-        // The IR file was parsed as the positional — the run gets as far as the
-        // stream index, and refuses it in the words east-c uses.
-        assert.ok(!result.stderr.includes('Missing <ir_file>'), result.stderr);
-        assert.deepEqual(result.stderr.trimEnd().split('\n'), ['Error: --stream index 0 out of range (0 inputs)']);
+        const outputPath = join(tempDir, 'double-out.beast2');
+        const result = spawnSync(process.execPath, [bin, 'run', '-i', inputPath, irPath, '-p', '@elaraai/east-node-std', '-o', outputPath], { env: { ...process.env, E3_RUNNER_SEARCH_DIRS: stdDir }, encoding: 'utf8' });
+        assert.equal(result.status, 0, result.stderr);
+        assert.equal(decodeBeast2For(IntegerType)(new Uint8Array(readFileSync(outputPath))), 40n);
     });
     // ---- The stdin lifeline -----------------------------------------------
     it('a runner given the stdin lifeline exits once its stdin closes, mid-computation', async () => {
         // Gate (c): with --exit-with-parent and a stdin pipe nobody writes, the
-        // runner exits once that pipe closes. The sink opens the output file
-        // before the body runs, so the file's existence is the sign the runner
-        // is up and computing; the body loops forever after one emission — only
-        // the watcher stops it.
+        // runner exits once that pipe closes. A unit's set output directory is
+        // made before the body runs, so its existence is the sign the runner is
+        // up and computing; the body loops forever after one emission — only the
+        // watcher stops it.
         const spin = East.function([emitKeyType], NullType, ($, emit) => {
             $(emit(1n));
             const turns = $.let(0n);
@@ -647,11 +476,17 @@ describe('folding emit, the blob merge and the stdin lifeline (#770)', () => {
                 $.assign(turns, turns.add(1n));
             });
         });
+        writeIr('spin.beast2', spin);
+        const unitPath = join(tempDir, 'unit.beast2');
+        writeFileSync(unitPath, encodeBeast2For(UnitType)({
+            work: variant('run', { program: 'spin.beast2', inputs: [], output: variant('set', 'spin-output') }),
+            platforms: [],
+            threads: 1n,
+            result: 'result.beast2',
+        }));
         const bin = fileURLToPath(new URL('../bin/east-node.mjs', import.meta.url));
-        // As in the wide-input test: point the platform loader at east-node-std.
-        const stdDir = fileURLToPath(new URL('../../east-node-std', import.meta.url));
-        const outputPath = join(tempDir, 'spin-output.beast2');
-        const child = spawn(process.execPath, [bin, 'run', '--exit-with-parent', writeIr('spin.beast2', spin), '-p', '@elaraai/east-node-std', '--emit', 'set', '-o', outputPath], { env: { ...process.env, E3_RUNNER_SEARCH_DIRS: stdDir }, stdio: ['pipe', 'ignore', 'pipe'] });
+        const outputPath = join(tempDir, 'spin-output');
+        const child = spawn(process.execPath, [bin, 'exec', '--exit-with-parent', unitPath], { stdio: ['pipe', 'ignore', 'pipe'] });
         const exited = new Promise((resolve) => {
             child.on('exit', (code, signal) => resolve({ code, signal }));
         });
@@ -790,12 +625,27 @@ describe('frozen inputs', () => {
         return irPath;
     }
     const NestedT = DictType(IntegerType, StructType({ xs: ArrayType(IntegerType) }));
+    const nestedRows = [[1n, { xs: [1n, 2n] }], [2n, { xs: [] }], [3n, { xs: [3n] }]];
     function writeNestedInput() {
-        const table = new SortedMap([[1n, { xs: [1n, 2n] }], [2n, { xs: [] }], [3n, { xs: [3n] }]], compareFor(IntegerType));
         const inputPath = join(tempDir, 'nested.beast2');
-        writeFileSync(inputPath, encodeBeast2PagedFor(NestedT, { batchSize: 2 })(table));
+        writeFileSync(inputPath, encodeBeast2SegmentsFor(NestedT)([new Map(nestedRows.slice(0, 2)), new Map(nestedRows.slice(2))]));
         return inputPath;
     }
+    /** The same rows as a manifest directory — the form e3 stages a stored
+     *  collection in. */
+    function writeNestedManifest() {
+        const path = join(tempDir, 'nested.manifest.beast2');
+        const dir = `${path}.segments`;
+        mkdirSync(dir);
+        const writer = new Beast2ManifestWriter(NestedT, {
+            object: (hash, bytes) => writeFileSync(join(dir, `${hash}.beast2`), bytes),
+            manifest: (bytes) => writeFileSync(path, bytes),
+        });
+        for (const row of nestedRows)
+            writer.add(row);
+        writer.finish();
+        return path;
+    }
     it('an input refuses mutation with the uniform copy-first error', async () => {
         const fn = East.function([NestedT], NullType, ($, d) => {
             $(d.insert(99n, { xs: [] }));
@@ -812,19 +662,26 @@ describe('frozen inputs', () => {
         await runProgram(writeIr(fn), [], [], [writeNestedInput()], outputPath);
         assert.equal(decodeBeast2For(IntegerType)(new Uint8Array(readFileSync(outputPath))), 4n);
     });
-    it('the frozen shape gate admits nested containers lazily: reads serve, writes refuse', async () => {
+    it('the frozen shape gate admits nested containers lazily, blob or manifest: reads serve, writes refuse', async () => {
         // Frozen is what makes lazy service safe for nested element shapes, so
-        // with a 1-byte threshold this opens pager-backed AND immutable.
+        // with a 1-byte threshold this opens pager-backed AND immutable. A gate
+        // that refused the shape would fall back to the eager frozen decode, which
+        // answers both the same, so the runner's own account, under -v, is what
+        // says the input was paged.
         const read = East.function([NestedT], IntegerType, ($, d) => d.get(1n).xs.size());
-        const outputPath = join(tempDir, 'out.beast2');
-        await runProgram(writeIr(read), [], [], [writeNestedInput()], outputPath, { lazyInputBytes: 1 });
-        assert.equal(decodeBeast2For(IntegerType)(new Uint8Array(readFileSync(outputPath))), 2n);
         const write = East.function([NestedT], IntegerType, ($, d) => {
             const row = $.let(d.get(1n));
             $(row.xs.pushLast(42n));
             return d.get(1n).xs.size();
         });
-        await assert.rejects(runProgram(writeIr(write), [], [], [writeNestedInput()], join(tempDir, 'out2.beast2'), { lazyInputBytes: 1 }), /cannot mutate a frozen value \(task inputs are immutable\) — copy first/);
+        for (const input of [writeNestedInput(), writeNestedManifest()]) {
+            const outputPath = join(tempDir, 'out.beast2');
+            const readErr = await stderrOf(() => withLazyThreshold(1, () => runProgram(writeIr(read), [], [], [input], outputPath, true)));
+            assert.ok(readErr.includes('input 0: opened lazily'), `${input} was paged:\n${readErr}`);
+            assert.equal(decodeBeast2For(IntegerType)(new Uint8Array(readFileSync(outputPath))), 2n);
+            const writeErr = await stderrOf(() => withLazyThreshold(1, () => assert.rejects(runProgram(writeIr(write), [], [], [input], join(tempDir, 'out2.beast2'), true), /cannot mutate a frozen value \(task inputs are immutable\) — copy first/)));
+            assert.ok(writeErr.includes('input 0: opened lazily'), `${input} was paged:\n${writeErr}`);
+        }
     });
 });
 describe('lazy input threshold resolution', () => {
@@ -837,21 +694,19 @@ describe('lazy input threshold resolution', () => {
     });
     it('defaults to 64 MiB when the environment variable is unset or empty', () => {
         delete process.env.EAST_LAZY_INPUT_BYTES;
-        assert.equal(lazyThreshold({}), 64 * 1024 * 1024);
+        assert.equal(lazyThreshold(), 64 * 1024 * 1024);
         process.env.EAST_LAZY_INPUT_BYTES = '';
-        assert.equal(lazyThreshold({}), 64 * 1024 * 1024, 'empty must fall through to the default, not disable lazy opening');
+        assert.equal(lazyThreshold(), 64 * 1024 * 1024, 'empty must fall through to the default, not disable lazy opening');
     });
     it('honours numeric overrides, 0 as the kill switch, and falls back on invalid values', () => {
         process.env.EAST_LAZY_INPUT_BYTES = '0';
-        assert.equal(lazyThreshold({}), 0, '0 disables lazy opening');
+        assert.equal(lazyThreshold(), 0, '0 disables lazy opening');
         process.env.EAST_LAZY_INPUT_BYTES = '123';
-        assert.equal(lazyThreshold({}), 123);
+        assert.equal(lazyThreshold(), 123);
         process.env.EAST_LAZY_INPUT_BYTES = '-5';
-        assert.equal(lazyThreshold({}), 64 * 1024 * 1024, 'negative values fall back to the default');
+        assert.equal(lazyThreshold(), 64 * 1024 * 1024, 'negative values fall back to the default');
         process.env.EAST_LAZY_INPUT_BYTES = 'not-a-number';
-        assert.equal(lazyThreshold({}), 64 * 1024 * 1024, 'garbage falls back to the default');
-        process.env.EAST_LAZY_INPUT_BYTES = '999';
-        assert.equal(lazyThreshold({ lazyInputBytes: 7 }), 7, 'the explicit option wins over the environment');
+        assert.equal(lazyThreshold(), 64 * 1024 * 1024, 'garbage falls back to the default');
     });
 });
 //# sourceMappingURL=runner.spec.js.map