arcane-os 0.57.0 → 0.59.0

package/src/diarization/native/main.cpp

@@ -0,0 +1,269 @@
+#include <nemo_speech/diar.h>
+
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#endif
+
+namespace {
+
+using StreamHandle = std::unique_ptr<nemo_speech_diar_stream, decltype(&nemo_speech_diar_stream_close)>;
+using ModelHandle = std::unique_ptr<nemo_speech_diar_model, decltype(&nemo_speech_diar_destroy)>;
+
+struct Stream {
+    StreamHandle handle;
+    int sample_rate;
+    bool probabilities;
+    bool finished = false;
+    int64_t delivered_frames = 0;
+};
+
+void check(nemo_speech_asr_status status) {
+    if (status != NEMO_SPEECH_ASR_OK) {
+        throw std::runtime_error(nemo_speech_asr_last_error());
+    }
+}
+
+std::string json_string(const std::string& value) {
+    std::ostringstream output;
+    output << '"';
+    for (const unsigned char character : value) {
+        switch (character) {
+            case '"': output << "\\\""; break;
+            case '\\': output << "\\\\"; break;
+            case '\n': output << "\\n"; break;
+            case '\r': output << "\\r"; break;
+            case '\t': output << "\\t"; break;
+            default:
+                if (character < 0x20) {
+                    output << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+                           << static_cast<unsigned int>(character) << std::dec;
+                } else {
+                    output << character;
+                }
+        }
+    }
+    output << '"';
+    return output.str();
+}
+
+void emit_error(uint64_t request, const std::string& message) {
+    std::cout << "{\"request\":" << request << ",\"error\":" << json_string(message)
+              << "}\n" << std::flush;
+}
+
+void emit_ack(uint64_t request) {
+    std::cout << "{\"request\":" << request << ",\"ok\":true}\n" << std::flush;
+}
+
+// Only transport framing uses sample count * sizeof(float). Samples are decoded
+// losslessly from little-endian float32; the caller's audio is never normalized.
+std::vector<float> read_audio(size_t samples) {
+    std::vector<float> audio(samples);
+    std::vector<unsigned char> encoded(samples * sizeof(float));
+    if (!std::cin.read(reinterpret_cast<char*>(encoded.data()), encoded.size())) {
+        throw std::runtime_error("Diarization input ended during an audio frame.");
+    }
+    for (size_t index = 0; index < samples; ++index) {
+        const auto* value = encoded.data() + index * sizeof(float);
+        const uint32_t bits = static_cast<uint32_t>(value[0])
+            | (static_cast<uint32_t>(value[1]) << 8)
+            | (static_cast<uint32_t>(value[2]) << 16)
+            | (static_cast<uint32_t>(value[3]) << 24);
+        std::memcpy(&audio[index], &bits, sizeof(float));
+    }
+    return audio;
+}
+
+void emit_result(uint64_t request, Stream& stream, int speakers, double seconds_per_frame) {
+    const int64_t frame_count = nemo_speech_diar_frame_count(stream.handle.get());
+    if (!stream.finished && frame_count == stream.delivered_frames) {
+        // Many small caller pushes only fill the native right-context buffer.
+        // Do not re-scan and serialize unchanged history for those pushes.
+        emit_ack(request);
+        return;
+    }
+    size_t count = 0;
+    check(nemo_speech_diar_segments(stream.handle.get(), nullptr, nullptr, 0, &count));
+    std::vector<nemo_speech_diar_segment> segments(count);
+    if (count != 0) {
+        check(nemo_speech_diar_segments(stream.handle.get(), nullptr, segments.data(), count, &count));
+    }
+
+    const int64_t retained_start = nemo_speech_diar_frame_probs_start(stream.handle.get());
+    std::vector<float> probabilities;
+    if (stream.probabilities) {
+        if (retained_start > stream.delivered_frames) {
+            throw std::runtime_error("Upstream compacted probability frames before they could be delivered.");
+        }
+        probabilities.resize(static_cast<size_t>(frame_count - retained_start) * speakers);
+        if (!probabilities.empty()) {
+            check(nemo_speech_diar_frame_probs(stream.handle.get(), probabilities.data(), probabilities.size()));
+        }
+    }
+
+    // Build one complete protocol record before writing it. A C-ABI failure
+    // therefore cannot leave a partially emitted result on stdout.
+    std::ostringstream output;
+    output << std::setprecision(std::numeric_limits<double>::max_digits10);
+    output << "{\"request\":" << request << ",\"result\":{\"final\":"
+           << (stream.finished ? "true" : "false")
+           << ",\"speakers\":" << speakers
+           << ",\"secondsPerFrame\":" << seconds_per_frame
+           << ",\"frameCount\":" << frame_count << ",\"segments\":[";
+    for (size_t index = 0; index < count; ++index) {
+        const auto& segment = segments[index];
+        if (index != 0) output << ',';
+        output << "{\"speaker\":" << segment.speaker << ",\"startTime\":" << segment.start_time
+               << ",\"endTime\":" << segment.end_time << '}';
+    }
+    output << ']';
+    if (stream.probabilities) {
+        output << ",\"probabilities\":{\"startFrame\":" << stream.delivered_frames
+               << ",\"values\":[";
+        const size_t first = static_cast<size_t>(stream.delivered_frames - retained_start) * speakers;
+        for (size_t index = first; index < probabilities.size(); ++index) {
+            if (index != first) output << ',';
+            output << probabilities[index];
+        }
+        output << "]}";
+    }
+    output << "}}\n";
+    std::cout << output.str() << std::flush;
+    stream.delivered_frames = frame_count;
+}
+
+int serve(const std::string& model_path) {
+#ifdef _WIN32
+    _setmode(_fileno(stdin), _O_BINARY);
+    _setmode(_fileno(stdout), _O_BINARY);
+#endif
+    nemo_speech_diar_model_config configuration = {};
+    configuration.size = sizeof(configuration);
+    configuration.model_path = model_path.c_str();
+    configuration.gpu = -1;
+    configuration.preset = "v3-streaming";
+    configuration.left_context_frames = -1;
+    nemo_speech_diar_model* raw_model = nullptr;
+    check(nemo_speech_diar_create(&configuration, &raw_model));
+    const ModelHandle model(raw_model, nemo_speech_diar_destroy);
+    const int speakers = nemo_speech_diar_num_speakers(model.get());
+    const double seconds_per_frame = nemo_speech_diar_seconds_per_frame(model.get());
+
+    // Streams are destroyed before their retained model. The C ABI serializes
+    // model compute internally; one command loop also preserves each stream's
+    // required single-threaded access without duplicating the native scheduler.
+    std::map<uint64_t, Stream> streams;
+    std::cout << "{\"ready\":true,\"speakers\":" << speakers
+              << ",\"secondsPerFrame\":" << std::setprecision(17) << seconds_per_frame
+              << "}\n" << std::flush;
+
+    std::string line;
+    while (std::getline(std::cin, line)) {
+        uint64_t request = 0;
+        uint64_t id = 0;
+        std::string operation;
+        std::istringstream command(line);
+        if (!(command >> operation >> request >> id)) {
+            emit_error(request, "Unreadable diarization command.");
+            return 1;
+        }
+        try {
+            if (operation == "open") {
+                int sample_rate = 0;
+                int probabilities = 0;
+                if (!(command >> sample_rate >> probabilities)) {
+                    throw std::runtime_error("Unreadable stream configuration.");
+                }
+                if (streams.count(id)) throw std::runtime_error("The stream is already open.");
+                nemo_speech_diar_stream* raw_stream = nullptr;
+                check(nemo_speech_diar_stream_open(model.get(), &raw_stream));
+                streams.emplace(id, Stream{
+                    StreamHandle(raw_stream, nemo_speech_diar_stream_close), sample_rate, probabilities != 0
+                });
+                emit_ack(request);
+            } else if (operation == "close") {
+                streams.erase(id);
+                emit_ack(request);
+            } else {
+                // Consume the complete framed audio before looking up its owner,
+                // so an operation error cannot desynchronize the command stream.
+                std::vector<float> audio;
+                if (operation == "push") {
+                    size_t samples = 0;
+                    if (!(command >> samples)) throw std::runtime_error("Unreadable audio sample count.");
+                    audio = read_audio(samples);
+                }
+                Stream& stream = streams.at(id);
+                if (stream.finished) throw std::runtime_error("The stream has already finished.");
+                if (operation == "push") {
+                    check(nemo_speech_diar_stream_push_f32(
+                        stream.handle.get(), audio.data(), audio.size(), stream.sample_rate
+                    ));
+                } else if (operation == "finish") {
+                    check(nemo_speech_diar_stream_finish(stream.handle.get()));
+                    stream.finished = true;
+                } else {
+                    throw std::runtime_error("Unknown diarization operation.");
+                }
+                emit_result(request, stream, speakers, seconds_per_frame);
+            }
+        } catch (const std::exception& error) {
+            emit_error(request, error.what());
+            if (!std::cin) return 1;
+        }
+    }
+    // EOF is the owner's graceful shutdown. No stream outlives the model, and
+    // there is no claim that EOF interrupts an active native inference call.
+    return 0;
+}
+
+int run(const std::string& model_path) {
+    try {
+        return serve(model_path);
+    } catch (const std::exception& error) {
+        emit_error(0, error.what());
+        return 1;
+    }
+}
+
+} // namespace
+
+#ifdef _WIN32
+int wmain(int argc, wchar_t** argv) {
+    if (argc != 2) {
+        emit_error(0, "Usage: arcane-diarization MODEL.gguf");
+        return 1;
+    }
+    const int length = WideCharToMultiByte(CP_UTF8, 0, argv[1], -1, nullptr, 0, nullptr, nullptr);
+    if (length == 0) {
+        emit_error(0, "Windows could not encode the selected model path as UTF-8.");
+        return 1;
+    }
+    std::string model_path(length, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, argv[1], -1, model_path.data(), length, nullptr, nullptr);
+    model_path.pop_back();
+    return run(model_path);
+}
+#else
+int main(int argc, char** argv) {
+    if (argc != 2) {
+        emit_error(0, "Usage: arcane-diarization MODEL.gguf");
+        return 1;
+    }
+    return run(argv[1]);
+}
+#endif

package/src/diarization/service.mjs

@@ -0,0 +1,129 @@
+import path from 'node:path';
+import Is from 'strong-type';
+import {createDiarization} from './index.mjs';
+import {serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+
+const is = new Is(false);
+
+/** Synchronous Core service factory; loading waits only at diarization calls. */
+export function createDiarizationService(options = {}, launch = {}) {
+    const workspaceRoot = launch.workspaceRoot ?? launch.appRoot ?? process.cwd();
+    const streams = new Map();
+    let nextStream = 0;
+    let model = null;
+    let context = null;
+    let closing = null;
+    let unsubscribe = null;
+
+    function current() {
+        const state = model?.current() ?? {state: 'unloaded', model: 'nvidia/Nemotron-3-Diarization'};
+        return {...state, error: state.error ? serializeCoreError(state.error) : null};
+    }
+
+    function load() {
+        if (closing) throw new Error('The diarization service is closing.');
+        if (!model) {
+            model = createDiarization({
+                executable: resolveSelectedPath(options.executable, workspaceRoot, 'executable'),
+                modelPath: resolveSelectedPath(options.modelPath, workspaceRoot, 'modelPath'),
+                runtime: options.runtime,
+                onEvent: options.onEvent
+            });
+            unsubscribe = model.subscribe(function modelState() {
+                context?.emit('diarization.state', current());
+            });
+        }
+        return model.ready;
+    }
+
+    function streamFor(id) {
+        const stream = streams.get(id);
+        if (!stream) throw new Error(`Diarization stream ${id} is not open.`);
+        return stream;
+    }
+
+    async function open({sampleRate = 16000, probabilities = false} = {}) {
+        await load();
+        const streamId = ++nextStream;
+        const stream = await model.openStream({
+            sampleRate,
+            onUpdate: function update(result) {
+                context?.emit('diarization.update', {streamId, result});
+            },
+            onProbabilities: probabilities ? function probabilityFrames(result) {
+                context?.emit('diarization.probabilities', {streamId, ...result});
+            } : undefined
+        });
+        streams.set(streamId, stream);
+        return {streamId, sampleRate};
+    }
+
+    async function push({streamId, audio}) {
+        return streamFor(streamId).push(decodeAudio(audio));
+    }
+
+    async function finish({streamId}) {
+        const stream = streamFor(streamId);
+        try { return await stream.finish(); } finally { streams.delete(streamId); }
+    }
+
+    async function cancel({streamId}) {
+        const stream = streams.get(streamId);
+        if (stream) {
+            try { await stream.cancel(); } finally { streams.delete(streamId); }
+        }
+        return {streamId, cancelled: true};
+    }
+
+    async function recording({audio, sampleRate = 16000}, {signal}) {
+        await load();
+        return model.diarize({audio: decodeAudio(audio), sampleRate, signal});
+    }
+
+    function drain() {
+        if (closing) return closing;
+        closing = (async function drainService() {
+            try { await model?.close(); } finally {
+                unsubscribe?.();
+                streams.clear();
+            }
+        })();
+        return closing;
+    }
+
+    return {
+        name: 'diarization',
+        start: function attachRuntime(owner) { context = owner; },
+        methods: {
+            'diarization.status': current,
+            'diarization.load': {lifetime: 'service', handle: load},
+            'diarization.open': {lifetime: 'service', handle: open},
+            'diarization.push': {lifetime: 'service', handle: push},
+            'diarization.finish': {lifetime: 'service', handle: finish},
+            'diarization.cancel': {lifetime: 'service', handle: cancel},
+            'diarization.recording': recording
+        },
+        drain,
+        dispose: drain
+    };
+}
+
+function resolveSelectedPath(value, workspaceRoot, name) {
+    if (!is.string(value)) throw new TypeError(`Diarization requires ${name}.`);
+    return path.resolve(workspaceRoot, value);
+}
+
+function decodeAudio(audio) {
+    if (audio?.encoding !== 'f32le' || !is.string(audio.data)) {
+        throw new TypeError('Core audio requires {encoding: "f32le", data: BASE64}.');
+    }
+    const encoded = Buffer.from(audio.data, 'base64');
+    // Framing belongs to the transport. A partial sample is not usable audio.
+    if (encoded.length % 4 !== 0) throw new TypeError('The f32le transport ends during a sample.');
+    const samples = new Float32Array(encoded.length / 4);
+    const bits = new Uint32Array(samples.buffer);
+    for (let index = 0; index < samples.length; index++) bits[index] = encoded.readUInt32LE(index * 4);
+    return samples;
+}
+
+export default createDiarizationService;

package/src/git-text-snapshot.mjs

@@ -0,0 +1,265 @@
+import Is from 'strong-type';
+import {mkdir, readdir} from 'node:fs/promises';
+import path from 'node:path';
+import {runProcess} from './process.mjs';
+import {ArcaneError, ERROR_CODES, throwIfAborted} from './errors.mjs';
+import {createEventQueue} from './event-queue.mjs';
+
+const is = new Is(false);
+const snapshotRef = 'refs/arcane/text-snapshot';
+
+/**
+ * Read complete selected text from a fetched revision, never a working tree.
+ * One application service owns each dedicated cache directory. Construction
+ * performs no I/O; refresh coalesces callers and close drains accepted work.
+ */
+export function createGitTextSnapshot({cacheDirectory, remote, ref, selectPath, onEvent, run = runProcess} = {}) {
+    for (const [name, value] of Object.entries({cacheDirectory, remote, ref})) {
+        if (!is.string(value) || value === '') throw new TypeError(`${name} must be a nonempty string.`);
+    }
+    if (!is.function(selectPath)) throw new TypeError('selectPath must be a function.');
+    const directory = path.resolve(cacheDirectory);
+    let prepared = false;
+    let retained = null;
+    let active = null;
+    let closing = null;
+
+    async function git(args, options = {}) {
+        let outputFailure;
+        const execution = {...options};
+        if (options.onOutput) {
+            execution.onOutput = async function consumeGitOutput(record) {
+                try { await options.onOutput(record); }
+                catch (error) { outputFailure ??= error; throw error; }
+            };
+        }
+        try {
+            return await run('git', ['--git-dir', directory, ...args], execution);
+        } catch (error) {
+            // runProcess first drains its child and preserves complete transport
+            // failures. Keep the Git parser's public code with that full cause.
+            if (outputFailure instanceof ArcaneError) {
+                throw new ArcaneError(outputFailure.code, outputFailure.message,
+                    {details: outputFailure.details, cause: error});
+            }
+            throw error;
+        }
+    }
+
+    async function prepare(events) {
+        if (prepared) return;
+        await mkdir(directory, {recursive: true});
+        if ((await readdir(directory)).length === 0) {
+            await run('git', ['init', '--bare', directory], {onEvent: events.send});
+        }
+        const result = await git(['rev-parse', '--is-bare-repository'], {onEvent: events.send});
+        // This is the selected cache's functional role: never reinterpret an
+        // existing working checkout as disposable object-cache storage.
+        if (result.stdout.trim() !== 'true') {
+            throw new ArcaneError('ARCANE_GIT_SNAPSHOT_CACHE_INVALID', 'The snapshot cache must be a bare Git repository.');
+        }
+        prepared = true;
+    }
+
+    async function acquire() {
+        const events = createEventQueue(onEvent);
+        try {
+            await events.send({type: 'git.snapshot.refreshing', message: 'Refreshing the selected repository revision.', data: {ref}});
+            await prepare(events);
+            await git(['fetch', '--no-tags', '--no-write-fetch-head', '--', remote, `+${ref}:${snapshotRef}`], {onEvent: events.send});
+            const selected = await git(['rev-parse', '--verify', `${snapshotRef}^{commit}`], {onEvent: events.send});
+            const revision = selected.stdout.trim();
+            if (retained?.revision === revision) {
+                await events.send({type: 'git.snapshot.completed', message: 'The selected repository revision is unchanged.', data: {revision, reused: true}});
+                await events.drain();
+                return retained;
+            }
+
+            const entries = [];
+            let treeParts = [];
+            await git(['ls-tree', '-r', '-z', '--full-tree', revision], {
+                outputEncoding: {stdout: null},
+                captureOutput: {stdout: false},
+                emitOutputEvents: {stdout: false},
+                onEvent: events.send,
+                onOutput: async function readTree({stream, chunk}) {
+                    if (stream !== 'stdout') return;
+                    let start = 0;
+                    for (let end = chunk.indexOf(0); end !== -1; end = chunk.indexOf(0, start)) {
+                        treeParts.push(chunk.subarray(start, end));
+                        const record = Buffer.concat(treeParts);
+                        treeParts = [];
+                        const tab = record.indexOf(9);
+                        if (tab < 0) throw protocolError('Git returned an unreadable tree record.', {record});
+                        const [mode, type, object] = record.subarray(0, tab).toString('ascii').split(' ');
+                        const filename = decodeText(record.subarray(tab + 1), 'repository path');
+                        if (await selectPath(filename)) {
+                            if (type !== 'blob') throw new ArcaneError('ARCANE_GIT_SNAPSHOT_NOT_TEXT',
+                                `The selected path is a ${type}, not a text blob.`, {details: {path: filename, mode, type}});
+                            entries.push({path: filename, object});
+                        }
+                        start = end + 1;
+                    }
+                    if (start < chunk.length) treeParts.push(chunk.subarray(start));
+                }
+            });
+            if (treeParts.length) throw protocolError('Git ended before its tree record delimiter.', {record: Buffer.concat(treeParts)});
+
+            const reader = createBlobReader(entries);
+            if (entries.length) {
+                async function* requestedObjects() {
+                    for (const entry of entries) yield `${entry.object}\n`;
+                }
+                await git(['cat-file', '--batch'], {
+                    input: requestedObjects(),
+                    outputEncoding: {stdout: null},
+                    captureOutput: {stdout: false},
+                    emitOutputEvents: {stdout: false},
+                    onEvent: events.send,
+                    onOutput: function readBlobs({stream, chunk}) {
+                        if (stream === 'stdout') reader.write(chunk);
+                    }
+                });
+            }
+            const result = {revision, files: reader.finish()};
+            await events.send({type: 'git.snapshot.completed', message: 'Repository text snapshot is ready.', data: {revision, reused: false}});
+            await events.drain();
+            retained = result;
+            return result;
+        } catch (error) {
+            try {
+                await events.send({type: 'git.snapshot.failed', message: 'Repository text snapshot failed.', data: {error}});
+                await events.drain();
+            } catch (observerError) {
+                if (observerError !== error) throw new AggregateError([error, observerError], 'Snapshot operation and event delivery failed.');
+            }
+            throw error;
+        }
+    }
+
+    function refresh({signal} = {}) {
+        try {
+            throwIfAborted(signal);
+            if (closing) throw new ArcaneError('CORE_CLOSING', 'The Git snapshot owner is closing.');
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        if (!active) {
+            // Install ownership before an observer can issue another refresh.
+            active = Promise.resolve().then(acquire);
+            const accepted = active;
+            function settled() { if (active === accepted) active = null; }
+            accepted.then(settled, settled);
+        }
+        return waitForSnapshot(active, signal).then(function copyResult(snapshot) {
+            return {revision: snapshot.revision, files: snapshot.files.map(function copyFile(file) { return {...file}; })};
+        });
+    }
+
+    function close() {
+        if (!closing) {
+            closing = (active ?? Promise.resolve()).then(function drained() { retained = null; });
+        }
+        return closing;
+    }
+
+    return {refresh, close, drain: close, dispose: close};
+}
+
+function waitForSnapshot(operation, signal) {
+    if (!signal) return operation;
+    return new Promise(function wait(resolve, reject) {
+        function abort() {
+            signal.removeEventListener('abort', abort);
+            reject(new ArcaneError(ERROR_CODES.cancelled, 'The snapshot caller was cancelled.', {cause: signal.reason, exitCode: 130}));
+        }
+        signal.addEventListener('abort', abort, {once: true});
+        operation.then(function completed(result) {
+            signal.removeEventListener('abort', abort);
+            if (!signal.aborted) resolve(result);
+        }, function failed(error) {
+            signal.removeEventListener('abort', abort);
+            if (!signal.aborted) reject(error);
+        });
+        if (signal.aborted) abort();
+    });
+}
+
+function decodeText(input, filename) {
+    try {
+        // ignoreBOM preserves an authored leading U+FEFF instead of consuming it.
+        return new TextDecoder('utf-8', {fatal: true, ignoreBOM: true}).decode(input);
+    } catch (cause) {
+        throw new ArcaneError('ARCANE_GIT_SNAPSHOT_NOT_TEXT', 'The selected Git content cannot be represented as UTF-8 text.',
+            {cause, details: {path: filename}});
+    }
+}
+
+function protocolError(message, details) {
+    return new ArcaneError('ARCANE_GIT_SNAPSHOT_PROTOCOL', message, {details});
+}
+
+function createBlobReader(entries) {
+    const files = [];
+    let headerParts = [];
+    let state = 'header';
+    let remaining = 0n;
+    let content = [];
+    let decoder;
+
+    function write(chunk) {
+        let offset = 0;
+        while (offset < chunk.length) {
+            if (state === 'header') {
+                const newline = chunk.indexOf(10, offset);
+                if (newline === -1) { headerParts.push(chunk.subarray(offset)); return; }
+                headerParts.push(chunk.subarray(offset, newline));
+                const header = Buffer.concat(headerParts).toString('ascii');
+                headerParts = [];
+                const [object, type, extent] = header.split(' ');
+                const entry = entries[files.length];
+                if (!entry || object !== entry.object || type !== 'blob' || !/^\d+$/u.test(extent)) {
+                    throw protocolError('Git returned an unexpected blob response.', {header, path: entry?.path});
+                }
+                // Git requires this encoded extent to delimit the raw body.
+                // It never enters product metadata, admission or progress.
+                remaining = BigInt(extent);
+                decoder = new TextDecoder('utf-8', {fatal: true, ignoreBOM: true});
+                content = [];
+                offset = newline + 1;
+                state = remaining === 0n ? 'delimiter' : 'body';
+            } else if (state === 'body') {
+                const available = chunk.length - offset;
+                const taking = remaining < BigInt(available) ? Number(remaining) : available;
+                try {
+                    content.push(decoder.decode(chunk.subarray(offset, offset + taking), {stream: true}));
+                } catch (cause) {
+                    throw new ArcaneError('ARCANE_GIT_SNAPSHOT_NOT_TEXT', 'The selected Git blob is not UTF-8 text.',
+                        {cause, details: {path: entries[files.length].path}});
+                }
+                offset += taking;
+                remaining -= BigInt(taking);
+                if (remaining === 0n) state = 'delimiter';
+            } else {
+                if (chunk[offset] !== 10) throw protocolError('Git returned an unreadable blob delimiter.', {path: entries[files.length].path});
+                try { content.push(decoder.decode()); }
+                catch (cause) {
+                    throw new ArcaneError('ARCANE_GIT_SNAPSHOT_NOT_TEXT', 'The selected Git blob ended inside a UTF-8 character.',
+                        {cause, details: {path: entries[files.length].path}});
+                }
+                files.push({path: entries[files.length].path, content: content.join('')});
+                offset += 1;
+                state = 'header';
+            }
+        }
+    }
+
+    function finish() {
+        if (state !== 'header' || headerParts.length || files.length !== entries.length) {
+            throw protocolError('Git ended before all requested text blobs were returned.', {paths: entries.map(function filename(entry) { return entry.path; })});
+        }
+        return files;
+    }
+
+    return {write, finish};
+}