arcane-os 0.56.0 → 0.57.0

package/src/local-ai/config.mjs

@@ -0,0 +1,62 @@
+import {readFile, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import Is from 'strong-type';
+import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
+
+const is = new Is(false);
+export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama'];
+
+/** Runtime requirements are application configuration, separate from models. */
+export function normalizeLocalAIConfig(value) {
+    if (value === undefined) return undefined;
+    if (!value || !is.object(value) || is.array(value) || !is.array(value.runtimes)) {
+        throw new ArcaneError(ERROR_CODES.usage, 'localAI requires a runtimes array.');
+    }
+    const runtimes = value.runtimes.map(function runtimeRequirement(item) {
+        const record = is.string(item) ? {id: item} : item;
+        if (!record || !LOCAL_AI_RUNTIME_IDS.includes(record.id)) {
+            throw new ArcaneError(ERROR_CODES.usage, `Unknown local AI runtime: ${String(record?.id ?? item)}.`);
+        }
+        return {...record};
+    });
+    return {...value, runtimes};
+}
+
+export function parseLocalAIRuntimeSelection(value) {
+    if (value === undefined) return undefined;
+    const selected = is.string(value) ? value.split(',').map(function runtimeName(name) {
+        return name.trim();
+    }) : value;
+    return normalizeLocalAIConfig({runtimes: selected}).runtimes;
+}
+
+/** Add explicitly requested development runtimes to the authored app owner. */
+export async function configureDevelopmentLocalAI({appRoot, runtimes, signal} = {}) {
+    throwIfAborted(signal);
+    if (runtimes === undefined) return;
+    const selected = parseLocalAIRuntimeSelection(runtimes);
+    let filename = path.join(appRoot, 'arcane-app.json');
+    let record;
+    let authored = true;
+    try {
+        record = JSON.parse(await readFile(filename, {encoding: 'utf8', signal}));
+    } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+        authored = false;
+        filename = path.join(appRoot, 'arcane-package.json');
+        record = JSON.parse(await readFile(filename, {encoding: 'utf8', signal}));
+    }
+    const current = normalizeLocalAIConfig(authored ? record.native?.localAI : record.localAI);
+    const requirements = new Map((current?.runtimes ?? []).map(function runtimePair(runtime) {
+        return [runtime.id, runtime];
+    }));
+    for (const runtime of selected) {
+        requirements.set(runtime.id, {...requirements.get(runtime.id), ...runtime});
+    }
+    const localAI = {...current, runtimes: [...requirements.values()]};
+    if (authored) record.native = {...record.native, localAI};
+    else record.localAI = localAI;
+    throwIfAborted(signal);
+    await writeFile(filename, `${JSON.stringify(record, null, 2)}\n`, {encoding: 'utf8', signal});
+    return {path: filename, localAI};
+}

package/src/local-ai/dev.mjs

@@ -0,0 +1,390 @@
+import Is from 'strong-type';
+import {createCoreRuntime} from '../core/runtime.mjs';
+import {createLocalAIService} from '../core/services/local-ai.mjs';
+import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
+import {normalizeLocalAIConfig} from './config.mjs';
+import {discoverLocalAIRuntimes} from './discover.mjs';
+import {ensureLocalAIRuntimes} from './install.mjs';
+
+const is = new Is(false);
+
+// The managed application import map owns this public module's actual URL.
+const bootstrap = `import {getInstalledCoreClient,installCoreClient} from 'arcane-os/core/client';
+let client=getInstalledCoreClient();
+const installedRuntime=client?.runtime.current();
+if(installedRuntime?.connected===false&&installedRuntime.transport==='standalone'){
+    client.close();
+    client=null;
+}
+if(!client){
+    globalThis.__ARCANE_DEV_HTTP__=true;
+    const id=crypto.randomUUID();
+    let receive;
+    let events;
+    let resolveOpen;
+    let rejectOpen;
+    const pending=new Set();
+    const opened=new Promise((resolve,reject)=>{resolveOpen=resolve;rejectOpen=reject;});
+    opened.catch(()=>{});
+    const transport={
+        name:'development-http',
+        subscribe(listener){
+            receive=listener;
+            events=new EventSource('/events?client='+encodeURIComponent(id));
+            events.onopen=()=>resolveOpen();
+            events.onmessage=event=>{
+                const frame=JSON.parse(event.data);
+                if(frame.type==='response')pending.delete(frame.id);
+                receive(frame);
+            };
+            events.onerror=event=>{
+                const error=new Error('The local AI development connection closed. Reload to reconnect.');
+                error.code='LOCAL_AI_DEV_CONNECTION_CLOSED';
+                error.event=event;
+                events.close();
+                rejectOpen(error);
+                client?.failTransport(error);
+            };
+            return ()=>events.close();
+        },
+        async send(frame){
+            if(frame.type==='request')pending.add(frame.id);
+            if(frame.type==='control'&&frame.control==='requests.cancelAll')frame={...frame,requestIds:[...pending]};
+            try{
+                await opened;
+                const response=await fetch('/rpc?client='+encodeURIComponent(id),{
+                    method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(frame)
+                });
+                const result=await response.json();
+                if(!response.ok)throw Object.assign(new Error(result.error?.message??'The local AI request failed.'),result.error);
+                // Responses arrive after their chunks on this same SSE connection.
+            }catch(error){
+                if(frame.type==='request')pending.delete(frame.id);
+                throw error;
+            }
+        }
+    };
+    client=installCoreClient(globalThis,{transport,replayRuntimeState:true});
+}
+export {client};
+`;
+
+/** Start local preparation without delaying the application's HTTP listener. */
+export function createDevelopmentLocalAI({config, appRoot, directory, application, version, signal, onEvent} = {}) {
+    const selected = normalizeLocalAIConfig(config) ?? {runtimes: []};
+    const lifetime = new AbortController();
+    const operationSignal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
+    const sessions = new Map();
+    const requestOwners = new Map();
+    const streamOwners = new Map();
+    const operations = new Set();
+    const incoming = new Set();
+    let runtime;
+    let service;
+    let stopFrames;
+    let preparationError = null;
+    let closing = null;
+    let closed = false;
+
+    function diagnostic(error) {
+        if (operationSignal.aborted && (error?.name === 'AbortError' || error?.code === 'ARCANE_CANCELLED')) return;
+        if (!is.function(onEvent)) {
+            console.error('Local AI development failed.', error);
+            return;
+        }
+        try {
+            Promise.resolve(onEvent({type: 'local-ai.development.error', message: error.message, error: serializeCoreError(error)}))
+                .catch(function observerFailed(cause) { console.error('Local AI development observer failed.', cause, error); });
+        } catch (cause) { console.error('Local AI development observer failed.', cause, error); }
+    }
+
+    function sessionFor(id) {
+        let session = sessions.get(id);
+        if (!session) {
+            session = {id, connections: new Set(), requests: new Map(), cancelledRequests: new Set()};
+            sessions.set(id, session);
+        }
+        return session;
+    }
+
+    function writeFrame(connection, frame) {
+        const text = `data: ${JSON.stringify(frame)}\n\n`;
+        connection.writes = connection.writes.then(function writeNextFrame() {
+            if (connection.closed) return;
+            return new Promise(function awaitWrite(resolve, reject) {
+                function finish(error) {
+                    connection.response.removeListener('close', disconnected);
+                    if (error) reject(error);
+                    else resolve();
+                }
+                function disconnected() { finish(); }
+                connection.response.once('close', disconnected);
+                connection.response.write(text, finish);
+            });
+        }).catch(function streamWriteFailed(error) {
+            diagnostic(error);
+            connection.response.destroy(error);
+        });
+    }
+
+    function sendSession(session, frame) {
+        for (const connection of session.connections) writeFrame(connection, frame);
+    }
+
+    function event(event, data) {
+        return {protocol: CORE_PROTOCOL, type: 'event', event, data, time: new Date().toISOString()};
+    }
+
+    function routeFrame(frame) {
+        if (frame.type === 'response') {
+            const owner = requestOwners.get(frame.id);
+            if (owner) sendSession(owner, frame);
+            return;
+        }
+        if (frame.type !== 'event') return;
+        if (frame.data?.streamId !== undefined) {
+            const owner = streamOwners.get(frame.data.streamId);
+            if (owner) sendSession(owner, frame);
+            return;
+        }
+        for (const session of sessions.values()) sendSession(session, frame);
+    }
+
+    function replay(connection) {
+        if (!runtime || connection.closed) return;
+        const current = runtime.current();
+        if (current.state === 'ready') writeFrame(connection, event('core.ready', {version: current.version, app: current.application}));
+        writeFrame(connection, event('core.state', current));
+        for (const record of current.services) writeFrame(connection, event('core.service.state', record));
+        writeFrame(connection, event('localai.state', service.current()));
+    }
+
+    const ready = Promise.resolve().then(async function prepareLocalAI() {
+        operationSignal.throwIfAborted();
+        const discovered = await discoverLocalAIRuntimes({config: selected, appRoot, signal: operationSignal});
+        operationSignal.throwIfAborted();
+        const installed = await ensureLocalAIRuntimes({runtimes: discovered.missing, directory, signal: operationSignal, onEvent});
+        const runtimes = [...discovered.available, ...installed];
+        operationSignal.throwIfAborted();
+        service = createLocalAIService(selected, {appRoot, runtimes, signal: operationSignal, onEvent});
+        runtime = createCoreRuntime({application, version, services: [service]});
+        stopFrames = runtime.onFrame(routeFrame);
+        runtime.start();
+        return runtime;
+    });
+    ready.catch(function preparationFailed(error) {
+        preparationError = error;
+        diagnostic(error);
+    });
+
+    function waitForReady(signal) {
+        const waiting = AbortSignal.any([signal, operationSignal]);
+        if (waiting.aborted) return Promise.reject(waiting.reason);
+        return new Promise(function awaitPreparedCore(resolve, reject) {
+            function abort() {
+                waiting.removeEventListener('abort', abort);
+                reject(waiting.reason);
+            }
+            waiting.addEventListener('abort', abort, {once: true});
+            ready.then(function prepared(value) {
+                waiting.removeEventListener('abort', abort);
+                if (waiting.aborted) reject(waiting.reason);
+                else resolve(value);
+            }, function failed(error) {
+                waiting.removeEventListener('abort', abort);
+                reject(error);
+            });
+        });
+    }
+
+    function observe(operation) {
+        operations.add(operation);
+        operation.then(function operationDone() { operations.delete(operation); }, function operationFailed() { operations.delete(operation); });
+        return operation;
+    }
+
+    function cancelRequest(id) {
+        if (!runtime) return;
+        const task = runtime.handle({protocol: CORE_PROTOCOL, type: 'control', control: 'request.cancel', requestId: id});
+        observe(task).catch(diagnostic);
+    }
+
+    function disconnect(connection) {
+        if (connection.closed) return;
+        connection.closed = true;
+        const session = connection.session;
+        session.connections.delete(connection);
+        if (session.connections.size) return;
+        for (const request of session.requests.values()) {
+            request.controller.abort(new CoreError({code: 'LOCAL_AI_DEV_DISCONNECTED', message: 'The browser disconnected from local AI.'}));
+        }
+        if (!session.requests.size) sessions.delete(session.id);
+    }
+
+    function json(response, status, value) {
+        if (response.destroyed || response.writableEnded) return;
+        response.writeHead(status, {'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store'});
+        response.end(JSON.stringify(value));
+    }
+
+    async function dispatch(frame, session, controller) {
+        if (frame?.protocol !== CORE_PROTOCOL) throw new CoreError({code: 'INVALID_RPC_REQUEST', message: 'Unknown Core protocol.'});
+        if (frame.type === 'control' && frame.control === 'requests.cancelAll') {
+            for (const id of frame.requestIds ?? []) session.cancelledRequests.add(id);
+            for (const request of session.requests.values()) {
+                request.controller.abort();
+            }
+            return;
+        }
+        if (frame.type === 'control' && frame.control === 'request.cancel') {
+            session.cancelledRequests.add(frame.requestId);
+            const request = session.requests.get(frame.requestId);
+            if (request) {
+                request.controller.abort();
+            }
+            return;
+        }
+        if (frame.type !== 'request') {
+            await waitForReady(controller.signal);
+            controller.signal.throwIfAborted();
+            operationSignal.throwIfAborted();
+            if (frame.type === 'control' && frame.control === 'runtime.replay') {
+                for (const connection of session.connections) replay(connection);
+                return;
+            }
+            return runtime.handle(frame);
+        }
+        if (requestOwners.has(frame.id)) throw new CoreError({code: 'RPC_REQUEST_ID_ACTIVE', message: 'The request id is already active.'});
+        const owned = {id: frame.id, controller};
+        const streamId = frame.parameters?.streamId;
+        session.requests.set(frame.id, owned);
+        requestOwners.set(frame.id, session);
+        if (session.cancelledRequests.delete(frame.id)) controller.abort();
+        if (streamId !== undefined) streamOwners.set(streamId, session);
+        function cancelled() { cancelRequest(frame.id); }
+        controller.signal.addEventListener('abort', cancelled, {once: true});
+        try {
+            await waitForReady(controller.signal);
+            controller.signal.throwIfAborted();
+            operationSignal.throwIfAborted();
+            return await runtime.handle(frame);
+        } finally {
+            controller.signal.removeEventListener('abort', cancelled);
+            session.requests.delete(frame.id);
+            session.cancelledRequests.delete(frame.id);
+            requestOwners.delete(frame.id);
+            if (streamId !== undefined) streamOwners.delete(streamId);
+            if (!session.connections.size && !session.requests.size) sessions.delete(session.id);
+        }
+    }
+
+    async function handler(request, response) {
+        const url = new URL(request.url, 'http://arcane.local');
+        if (!['/rpc', '/events', '/arcane-local-ai.js'].includes(url.pathname)) return false;
+        if (closed) {
+            json(response, 503, {error: {code: 'LOCAL_AI_DEV_CLOSED', message: 'Local AI development is closed.'}});
+            return true;
+        }
+        if (url.pathname === '/arcane-local-ai.js') {
+            if (request.method !== 'GET' && request.method !== 'HEAD') {
+                json(response, 405, {error: {message: 'Use GET to load the local AI bootstrap.'}});
+                return true;
+            }
+            response.writeHead(200, {'Content-Type': 'text/javascript; charset=utf-8', 'Cache-Control': 'no-store'});
+            response.end(request.method === 'HEAD' ? undefined : bootstrap);
+            return true;
+        }
+        const clientId = url.searchParams.get('client');
+        if (!clientId) {
+            json(response, 400, {error: {code: 'LOCAL_AI_DEV_CLIENT_REQUIRED', message: 'Load the local AI development bootstrap before connecting.'}});
+            return true;
+        }
+        const method = url.pathname === '/events' ? 'GET' : 'POST';
+        if (request.method !== method) {
+            json(response, 405, {error: {message: `Use ${method} for ${url.pathname}.`}});
+            return true;
+        }
+        const session = sessionFor(clientId);
+        if (url.pathname === '/events') {
+            const connection = {response, session, closed: false, writes: Promise.resolve()};
+            session.connections.add(connection);
+            response.on('close', function eventConnectionClosed() { disconnect(connection); });
+            response.on('error', diagnostic);
+            response.writeHead(200, {'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-store', Connection: 'keep-alive'});
+            response.flushHeaders();
+            ready.then(function replayReadyRuntime() { replay(connection); }, function reportPreparationFailure(error) {
+                if (!connection.closed) writeFrame(connection, event('core.error', serializeCoreError(error)));
+            }).catch(diagnostic);
+            return true;
+        }
+        const controller = new AbortController();
+        const rpc = {request, response, controller};
+        incoming.add(rpc);
+        const abortOnClose = function rpcConnectionClosed() {
+            if (!response.writableEnded) controller.abort(new CoreError({code: 'LOCAL_AI_DEV_DISCONNECTED', message: 'The local AI request connection closed.'}));
+        };
+        response.once('close', abortOnClose);
+        let frame;
+        try {
+            request.setEncoding('utf8');
+            let body = '';
+            for await (const part of request) body += part;
+            frame = JSON.parse(body);
+            const result = await observe(dispatch(frame, session, controller));
+            json(response, 200, result ?? {ok: true});
+        } catch (error) {
+            diagnostic(error);
+            if (frame?.type === 'request' && frame.id) {
+                const result = {protocol: CORE_PROTOCOL, type: 'response', id: frame.id, ok: false, error: serializeCoreError(error), time: new Date().toISOString()};
+                sendSession(session, result);
+                json(response, 200, result);
+            } else json(response, 400, {error: serializeCoreError(error)});
+        } finally {
+            incoming.delete(rpc);
+            response.removeListener('close', abortOnClose);
+            if (!session.connections.size && !session.requests.size) sessions.delete(session.id);
+        }
+        return true;
+    }
+
+    function current() {
+        return {state: closed ? 'closed' : preparationError ? 'error' : runtime ? 'ready' : 'preparing',
+            error: preparationError ? serializeCoreError(preparationError) : null,
+            core: runtime?.current() ?? null, localAI: service?.current() ?? null};
+    }
+
+    function close() {
+        if (closing) return closing;
+        closed = true;
+        lifetime.abort();
+        for (const rpc of incoming) {
+            rpc.controller.abort(lifetime.signal.reason);
+            rpc.request.destroy();
+            rpc.response.destroy();
+        }
+        for (const session of sessions.values()) {
+            for (const connection of [...session.connections]) {
+                disconnect(connection);
+                connection.response.destroy();
+            }
+        }
+        closing = (async function closeLocalAI() {
+            try { await ready; } catch {}
+            try {
+                await runtime?.close();
+            } finally {
+                await Promise.allSettled([...operations]);
+                stopFrames?.();
+                sessions.clear();
+                signal?.removeEventListener('abort', abortDevelopment);
+            }
+            return current();
+        })();
+        return closing;
+    }
+
+    function abortDevelopment() { close().catch(diagnostic); }
+    signal?.addEventListener('abort', abortDevelopment, {once: true});
+    if (signal?.aborted) abortDevelopment();
+    return {ready, handler, current, close};
+}

package/src/local-ai/discover.mjs

@@ -0,0 +1,71 @@
+import {constants} from 'node:fs';
+import {access,stat} from 'node:fs/promises';
+import path from 'node:path';
+import {throwIfAborted} from '../errors.mjs';
+import {normalizeLocalAIConfig} from './config.mjs';
+import {inspectLocalAIServer,localAIConnectionRefused,localAIServerURL} from './server.mjs';
+
+async function pathExecutable(id,appRoot,signal){
+    const filename=`${id==='llama.cpp'?'llama-server':'ollama'}${process.platform==='win32'?'.exe':''}`;
+    for(const directory of (process.env.PATH??'').split(path.delimiter)){
+        throwIfAborted(signal);
+        if(!directory)continue;
+        const candidate=path.resolve(appRoot??process.cwd(),directory.replace(/^"|"$/gu,''),filename);
+        try{
+            await access(candidate,process.platform==='win32'?constants.F_OK:constants.X_OK);
+            if((await stat(candidate)).isFile())return candidate;
+        }catch(error){
+            if(!['ENOENT','ENOTDIR','EACCES','EPERM'].includes(error.code))throw error;
+        }
+    }
+    return null;
+}
+
+/** Discover development availability without installing or starting a process. */
+export async function discoverLocalAIRuntimes({config,appRoot,signal}={}){
+    const selected=normalizeLocalAIConfig(config)?.runtimes??[];
+    const outcomes=await Promise.allSettled(selected.map(async function discoverRuntime(requirement){
+        throwIfAborted(signal);
+        if(!['llama.cpp','ollama'].includes(requirement.id))return {missing:requirement};
+        const configuration=config[requirement.id==='llama.cpp'?'llamaCpp':'ollama']??{};
+        const url=localAIServerURL(requirement.id,configuration);
+        const concreteVersion=requirement.version&&requirement.version!=='latest';
+        let discovery;
+        try{
+            discovery=await inspectLocalAIServer({id:requirement.id,url,signal});
+        }catch(error){
+            throwIfAborted(signal);
+            if(!localAIConnectionRefused(error))throw error;
+        }
+        if(discovery){
+            const matches=!concreteVersion||(discovery.ready&&discovery.version?.replace(/^v/u,'')===requirement.version.replace(/^v/u,''));
+            if(!matches)return {missing:requirement};
+            // A response from an occupied endpoint is retained in full, even
+            // while loading or failing. It never triggers a competing install
+            // or process and is never presented as inference readiness.
+            return {available:{
+                id:requirement.id,version:discovery.version??'system',external:true,
+                url,platform:process.platform,architecture:process.arch,
+                ...(concreteVersion?{requestedVersion:requirement.version}:{}),discovery
+            }};
+        }
+        if(concreteVersion)return {missing:requirement};
+        const executable=await pathExecutable(requirement.id,appRoot,signal);
+        if(!executable)return {missing:requirement};
+        return {available:{
+            id:requirement.id,version:'system',external:true,executable,root:path.dirname(executable),
+            platform:process.platform,architecture:process.arch
+        }};
+    }));
+    const failures=outcomes.filter(function failedDiscovery(outcome){return outcome.status==='rejected';});
+    if(failures.length===1)throw failures[0].reason;
+    if(failures.length>1)throw new AggregateError(failures.map(function discoveryFailure(outcome){return outcome.reason;}),'Local AI runtime discovery failed.');
+    throwIfAborted(signal);
+    const available=[];
+    const missing=[];
+    for(const outcome of outcomes){
+        if(outcome.value.available)available.push(outcome.value.available);
+        else missing.push(outcome.value.missing);
+    }
+    return {available,missing};
+}

package/src/local-ai/http.mjs

@@ -0,0 +1,106 @@
+/** Send the caller's complete payload using only JSON transport encoding. */
+export async function requestLocalJSON({url, path = '', method = 'GET', payload, signal}) {
+    const response = await requestLocalResponse({url, path, method, payload, signal, accept: 'application/json'});
+    const body = await response.text();
+    return body === '' ? undefined : parseLocalJSON(body, response);
+}
+
+/** Yield upstream JSON records unchanged; the caller owns completion assembly. */
+export async function* streamLocalJSON({url, path = '', method = 'POST', payload, format = 'sse', signal, onOpen}) {
+    if (format !== 'sse' && format !== 'ndjson') {
+        throw new TypeError(`Unsupported local AI stream format: ${format}.`);
+    }
+    const response = await requestLocalResponse({
+        url, path, method, payload, signal,
+        accept: format === 'sse' ? 'text/event-stream' : 'application/x-ndjson'
+    });
+    let data = [];
+    for await (const line of readLocalLines(response, onOpen)) {
+        if (format === 'ndjson') {
+            if (line !== '') yield parseLocalJSON(line, response);
+            continue;
+        }
+        if (line === '') {
+            if (!data.length) continue;
+            const body = data.join('\n');
+            data = [];
+            if (body === '[DONE]') return;
+            yield parseLocalJSON(body, response);
+            continue;
+        }
+        const separator = line.indexOf(':');
+        const field = separator < 0 ? line : line.slice(0, separator);
+        if (field !== 'data') continue;
+        const value = separator < 0 ? '' : line.slice(separator + 1);
+        data.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    if (data.length) {
+        const body = data.join('\n');
+        if (body !== '[DONE]') yield parseLocalJSON(body, response);
+    }
+}
+
+async function requestLocalResponse({url, path, method, payload, signal, accept}) {
+    const headers = {Accept: accept};
+    if (payload !== undefined) headers['Content-Type'] = 'application/json';
+    const response = await fetch(new URL(path, url), {
+        method,
+        headers,
+        body: payload === undefined ? undefined : JSON.stringify(payload),
+        signal
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        const error = new Error(`Local AI HTTP ${response.status} ${response.statusText}: ${body}`);
+        error.status = response.status;
+        error.body = body;
+        error.url = response.url;
+        throw error;
+    }
+    return response;
+}
+
+function parseLocalJSON(body, response) {
+    try {
+        return JSON.parse(body);
+    } catch (error) {
+        error.status = response.status;
+        error.body = body;
+        error.url = response.url;
+        throw error;
+    }
+}
+
+/** Remove only SSE/NDJSON line framing, including delimiters across reads. */
+async function* readLocalLines(response, onOpen) {
+    const chunks = response.body[Symbol.asyncIterator]();
+    const decoder = new TextDecoder('utf-8', {fatal: true});
+    let pending = '';
+    let precedingCarriageReturn = false;
+    try {
+        await onOpen?.(response);
+        while (true) {
+            const {value, done} = await chunks.next();
+            let text = done ? decoder.decode() : decoder.decode(value, {stream: true});
+            if (precedingCarriageReturn && text !== '') {
+                if (text.startsWith('\n')) text = text.slice(1);
+                precedingCarriageReturn = false;
+            }
+            let start = 0;
+            for (const delimiter of text.matchAll(/\r\n|\r|\n/g)) {
+                const line = pending + text.slice(start, delimiter.index);
+                pending = '';
+                start = delimiter.index + delimiter[0].length;
+                precedingCarriageReturn = delimiter[0] === '\r' && start === text.length;
+                yield line;
+            }
+            pending += text.slice(start);
+            if (done) {
+                if (pending !== '') yield pending;
+                return;
+            }
+        }
+    } finally {
+        await chunks.return();
+    }
+}