@agentshouse/kit 0.2.1-ce145e9aadbf6 → 0.2.1-ce3d2bb67177c

package/dist/events.js

@@ -0,0 +1,525 @@
+const COMMAND = { shown: 'command' };
+const HIDDEN = { shown: 'hidden' };
+const FINISHED = new Set(['completed', 'failed']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
+const MESSAGE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request', send_mail: 'request' };
+function words(line) {
+    const found = [];
+    let word = null;
+    let quote = null;
+    for (let index = 0; index < line.length; index++) {
+        const character = line[index];
+        if (quote !== null) {
+            if (character === quote)
+                quote = null;
+            else if (character === '\\' && quote === '"')
+                word += line[++index] ?? '';
+            else
+                word += character;
+        }
+        else if (character === "'" || character === '"') {
+            quote = character;
+            word ??= '';
+        }
+        else if (character === '\\') {
+            word = (word ?? '') + (line[++index] ?? '');
+        }
+        else if (/\s/.test(character)) {
+            if (word !== null)
+                found.push(word);
+            word = null;
+        }
+        else {
+            word = (word ?? '') + character;
+        }
+    }
+    if (word !== null)
+        found.push(word);
+    return found;
+}
+export function houseMessage(line) {
+    const [program, verb, json] = words(line.trim());
+    if (program !== 'house' || verb !== 'run_command' || json === undefined)
+        return null;
+    let call;
+    try {
+        call = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    const argument = MESSAGE_TARGETS[call.command];
+    if (argument === undefined)
+        return null;
+    const target = call.arguments?.[argument];
+    return { shown: 'message', command: call.command, target: typeof target === 'string' ? target : null };
+}
+function decidedByLine(command, final) {
+    const line = typeof command === 'string' ? command : Array.isArray(command) ? command.at(-1) : undefined;
+    if (typeof line !== 'string')
+        return final ? COMMAND : null;
+    return houseMessage(line) ?? COMMAND;
+}
+function contentText(content) {
+    const text = (content ?? [])
+        .map((entry) => (entry.type === 'content' && entry.content?.type === 'text' ? entry.content.text : ''))
+        .filter((part) => part !== '')
+        .join('\n');
+    return text === '' ? null : text;
+}
+function plan(entries) {
+    return entries.map((entry) => ({ content: entry.content, status: entry.status }));
+}
+function merged(into, from) {
+    if (from === null || from === undefined)
+        return into;
+    const result = { ...into };
+    for (const [key, value] of Object.entries(from)) {
+        result[key] =
+            typeof value === 'object' && value !== null && !Array.isArray(value) && typeof into[key] === 'object'
+                ? merged(into[key], value)
+                : value;
+    }
+    return result;
+}
+function names(input, ids) {
+    const values = JSON.stringify(input ?? {});
+    for (const id of ids)
+        if (values.includes(id))
+            return true;
+    return false;
+}
+class Reader {
+    session = null;
+    calls = new Map();
+    subagents = new Set();
+    done = new Set();
+    seenOptions = new Map();
+    requestedOptions = new Map();
+    compactions = new Set();
+    jobs = new Map();
+    read(message) {
+        if (message.method === undefined)
+            return this.answered(message.result);
+        const session = message.params?.sessionId;
+        if (session !== undefined && this.session !== null && session !== this.session) {
+            return this.elsewhere(session, message);
+        }
+        return this.own(message);
+    }
+    requested(option, value) {
+        this.requestedOptions.set(option, value);
+    }
+    refused(option) {
+        this.requestedOptions.delete(option);
+    }
+    closeTurn() {
+        const events = [];
+        for (const [id, call] of this.calls) {
+            if (call.decided?.shown === 'subagent')
+                continue;
+            if (call.decided === null)
+                events.push(...this.shown(call, this.decide(call, true)));
+            this.calls.delete(id);
+        }
+        return events;
+    }
+    answered(result) {
+        if (typeof result?.sessionId === 'string' && this.session === null)
+            this.session = result.sessionId;
+        for (const option of (result?.configOptions ?? [])) {
+            this.seenOptions.set(option.id, option.currentValue);
+            this.requestedOptions.delete(option.id);
+        }
+        return [];
+    }
+    elsewhere(_session, _message) {
+        return [];
+    }
+    own(message) {
+        if (message.method !== 'session/update')
+            return this.extension(message);
+        return this.update(message.params.update);
+    }
+    extension(_message) {
+        return [];
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'agent_message_chunk':
+                if (update.content.type === 'image')
+                    return [{ kind: 'image', data: update.content.data, mediaType: update.content.mimeType }];
+                return update.content.type === 'text' ? [{ kind: 'text', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'agent_thought_chunk':
+                return update.content.type === 'text' ? [{ kind: 'reasoning', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'tool_call':
+            case 'tool_call_update':
+                return this.tool(update);
+            case 'plan':
+                return [{ kind: 'plan', entries: plan(update.entries) }];
+            case 'usage_update':
+                return [{ kind: 'context', used: update.used, window: update.size }];
+            case 'current_mode_update':
+                return [{ kind: 'marker', marker: 'mode', text: update.currentModeId }];
+            case 'available_commands_update':
+                return [{ kind: 'commands', commands: update.availableCommands }];
+            case 'config_option_update':
+                return [{ kind: 'options', options: update.configOptions }, ...this.optionsChanged(update.configOptions)];
+            case 'compaction_update':
+                if (update.status !== 'completed' || this.compactions.has(update.compactionId))
+                    return [];
+                this.compactions.add(update.compactionId);
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'async_task_spawned':
+                return this.job(update.asyncTaskId, update.name ?? update.description ?? '', 'running');
+            case 'async_task_state_update':
+                return RUNNING_JOB.has(update.state) ? [] : this.job(update.asyncTaskId, null, update.state);
+            default:
+                return [];
+        }
+    }
+    job(id, name, state) {
+        if (name !== null)
+            this.jobs.set(id, name);
+        const label = this.jobs.get(id) ?? '';
+        if (state !== 'running')
+            this.jobs.delete(id);
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
+    }
+    optionsChanged(options) {
+        const events = [];
+        for (const option of options) {
+            const marker = this.watchedOptions[option.id];
+            const before = this.seenOptions.get(option.id);
+            this.seenOptions.set(option.id, option.currentValue);
+            if (marker === undefined || before === undefined || before === option.currentValue)
+                continue;
+            if (this.requestedOptions.get(option.id) === option.currentValue) {
+                this.requestedOptions.delete(option.id);
+                continue;
+            }
+            events.push({ kind: 'marker', marker, text: String(option.currentValue) });
+        }
+        return events;
+    }
+    tool(update) {
+        let call = this.calls.get(update.toolCallId);
+        if (call === undefined) {
+            if (update.sessionUpdate !== 'tool_call')
+                return [];
+            call = { id: update.toolCallId, decided: null, meta: {}, imaged: false, status: 'in_progress' };
+            this.calls.set(call.id, call);
+        }
+        if (update.kind !== undefined)
+            call.kind = update.kind;
+        if (update.title !== undefined)
+            call.title = update.title;
+        if (update.status !== undefined)
+            call.status = update.status;
+        if (update.rawInput !== undefined)
+            call.rawInput = merged(call.rawInput ?? {}, update.rawInput);
+        if (update.content !== undefined)
+            call.content = update.content;
+        call.meta = merged(call.meta, update._meta);
+        const events = [];
+        const finished = FINISHED.has(call.status);
+        if (call.decided === null) {
+            const decided = this.decide(call, finished);
+            if (decided !== null)
+                events.push(...this.shown(call, decided));
+        }
+        events.push(...this.produced(call));
+        if (call.decided?.shown === 'subagent' && finished)
+            events.push(...this.subagentFinished(call));
+        else if (finished)
+            this.calls.delete(call.id);
+        return events;
+    }
+    shown(call, decided) {
+        call.decided = decided;
+        switch (decided.shown) {
+            case 'command':
+                return [{ kind: 'command' }];
+            case 'hidden':
+                return [];
+            case 'message':
+                return [{ kind: 'message', command: decided.command, target: decided.target }];
+            case 'marker':
+                return [{ kind: 'marker', marker: decided.marker, text: decided.text }];
+            case 'subagent':
+                this.subagents.add(call.id);
+                return [{ kind: 'subagent', id: call.id, description: decided.description }];
+        }
+    }
+    produced(_call) {
+        return [];
+    }
+    subagentFinished(call) {
+        this.calls.delete(call.id);
+        return this.finish(call.id, contentText(call.content));
+    }
+    finish(id, result) {
+        if (!this.subagents.has(id) || this.done.has(id))
+            return [];
+        this.done.add(id);
+        this.calls.delete(id);
+        return [{ kind: 'subagent-done', id, result }];
+    }
+}
+class ClaudeReader extends Reader {
+    watchedOptions = { model: 'model' };
+    tasks = new Map();
+    own(message) {
+        if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
+            return [];
+        return super.own(message);
+    }
+    update(update) {
+        if (update.sessionUpdate === 'usage_update' && update._meta?.['_claude/origin'] !== undefined) {
+            return [...super.update(update), { kind: 'ended' }];
+        }
+        if (update.sessionUpdate === 'session_info_update' && update._meta?.jetbrains?.air?.sessionFailure !== undefined) {
+            return [{ kind: 'marker', marker: 'retry', text: update._meta.jetbrains.air.sessionFailure.title }];
+        }
+        return super.update(update);
+    }
+    extension(message) {
+        if (message.method !== '_claude/sdkMessage')
+            return [];
+        const sdk = message.params.message;
+        switch (sdk.subtype) {
+            case 'task_started':
+                if (sdk.tool_use_id !== undefined)
+                    this.tasks.set(sdk.task_id, sdk.tool_use_id);
+                return [];
+            case 'task_notification':
+                return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            default:
+                return [];
+        }
+    }
+    decide(call, final) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
+            const description = call.rawInput?.description;
+            if (description === undefined && !final)
+                return null;
+            return { shown: 'subagent', description: description ?? call.title ?? '' };
+        }
+        if (tool === 'TodoWrite' || tool === 'CronCreate')
+            return HIDDEN;
+        if (tool === 'ScheduleWakeup') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return call.rawInput.stop === true ? COMMAND : HIDDEN;
+        }
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (tool === 'Bash')
+            return decidedByLine(call.rawInput?.command, final);
+        if (tool === 'SendMessage' || tool === 'TaskStop') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return names(call.rawInput, this.tasks.keys()) ? HIDDEN : COMMAND;
+        }
+        return COMMAND;
+    }
+    produced(call) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (call.status !== 'completed')
+            return [];
+        if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
+        }
+        return [];
+    }
+    subagentFinished(call) {
+        if (call.meta.claudeCode?.toolResponse?.isAsync === true)
+            return [];
+        return super.subagentFinished(call);
+    }
+}
+const COLLABORATION = new Set(['spawnAgent', 'sendInput', 'resumeAgent', 'wait', 'closeAgent', 'followupTask']);
+class CodexReader extends Reader {
+    watchedOptions = { mode: 'mode', collaboration_mode: 'mode' };
+    children = new Map();
+    own(message) {
+        if (message.method === 'session/request_permission' && message.params.toolCall?.kind === 'switch_mode') {
+            return [{ kind: 'started' }, { kind: 'marker', marker: 'mode', text: message.params.toolCall.title ?? '' }];
+        }
+        return super.own(message);
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'session_info_update': {
+                const codex = update._meta?.codex;
+                if (codex?.threadStatus?.type === 'active')
+                    return [{ kind: 'started' }];
+                if (codex?.threadStatus?.type === 'idle')
+                    return [{ kind: 'ended' }];
+                if (codex?.error !== undefined)
+                    return [{ kind: 'marker', marker: 'retry', text: codex.error.message ?? '' }];
+                return [];
+            }
+            case 'notice':
+                return update.severity === 'info' ? [{ kind: 'marker', marker: 'model', text: update.description ?? update.title }] : [];
+            case 'subagent_spawned':
+                this.children.set(update.subagentSessionId, { id: null, text: '' });
+                this.subagents.add(update.subagentSessionId);
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
+            case 'subagent_state_update':
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
+            default:
+                return super.update(update);
+        }
+    }
+    elsewhere(session, message) {
+        const child = this.children.get(session);
+        const update = message.params?.update;
+        if (child === undefined || update === undefined)
+            return [];
+        if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+            const id = update.messageId ?? null;
+            if (child.id !== id)
+                child.text = '';
+            child.id = id;
+            child.text += update.content.text;
+        }
+        return [];
+    }
+    decide(call) {
+        const air = call.meta.jetbrains?.air;
+        if (COLLABORATION.has(call.title ?? ''))
+            return HIDDEN;
+        if (air?.subagent !== undefined)
+            return { shown: 'subagent', description: call.title ?? '' };
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (call.kind === 'execute')
+            return decidedByLine(call.rawInput?.command, true);
+        if (call.title === 'Image generation')
+            return HIDDEN;
+        return COMMAND;
+    }
+    produced(call) {
+        if (call.imaged || call.kind === 'read')
+            return [];
+        const image = (call.content ?? []).find((entry) => entry.type === 'content' && entry.content?.type === 'image');
+        if (image === undefined)
+            return [];
+        call.imaged = true;
+        return [{ kind: 'image', data: image.content.data, mediaType: image.content.mimeType }];
+    }
+}
+class GrokReader extends Reader {
+    watchedOptions = {};
+    children = new Map();
+    models = [];
+    model = null;
+    answered(result) {
+        if (result?.models !== undefined)
+            this.offered(result.models);
+        return super.answered(result);
+    }
+    read(message) {
+        const session = message.params?.sessionId;
+        if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
+            return [];
+        if (message.method === '_x.ai/queue/changed') {
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
+        }
+        if (message.params?.update?.sessionUpdate === 'turn_completed') {
+            return session === this.session ? [{ kind: 'ended' }] : [];
+        }
+        if (message.method === '_x.ai/models/update') {
+            this.offered(message.params);
+            return [];
+        }
+        return super.read(message);
+    }
+    offered(models) {
+        this.models = models.availableModels ?? this.models;
+        this.model = models.currentModelId ?? this.model;
+    }
+    window() {
+        return this.models.find((model) => model.modelId === this.model)?._meta?.totalContextTokens ?? null;
+    }
+    extension(message) {
+        const update = message.params?.update;
+        switch (message.method) {
+            case '_x.ai/task_backgrounded':
+                return this.job(update.task_id, update.description ?? update.command ?? '', 'running');
+            case '_x.ai/task_completed':
+                return this.job(update.task_snapshot.task_id, null, update.task_snapshot.exit_code === 0 ? 'completed' : 'failed');
+            case '_x.ai/scheduled_task_created':
+                return [{ kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
+            case '_x.ai/session_notification':
+                return this.notification(update);
+            default:
+                return [];
+        }
+    }
+    notification(update) {
+        switch (update.sessionUpdate) {
+            case 'response_completed': {
+                const usage = update.usage;
+                const window = this.window();
+                if (window === null)
+                    return [];
+                const used = usage.input_tokens + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + usage.output_tokens;
+                return [{ kind: 'context', used, window }];
+            }
+            case 'subagent_spawned': {
+                const call = [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' &&
+                    ![...this.children.values()].includes(candidate.id) &&
+                    candidate.decided.description === update.description) ??
+                    [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' && ![...this.children.values()].includes(candidate.id));
+                this.children.set(update.child_session_id, call?.id ?? null);
+                return [];
+            }
+            case 'subagent_finished': {
+                const call = this.children.get(update.child_session_id);
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
+            }
+            case 'auto_compact_completed':
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'model_auto_switched':
+                this.model = update.new_model_id;
+                return [{ kind: 'marker', marker: 'model', text: update.new_model_id }];
+            case 'retry_state':
+                return [{ kind: 'marker', marker: 'retry', text: update.message ?? update.reason ?? update.error_type ?? '' }];
+            default:
+                return [];
+        }
+    }
+    decide(call) {
+        const tool = (call.meta['x.ai/tool'] ?? {});
+        if (tool.name === 'spawn_subagent' || tool.kind === 'task') {
+            return { shown: 'subagent', description: call.rawInput?.description ?? call.title ?? '' };
+        }
+        if (tool.name === 'todo_write' || tool.name === 'scheduler_create')
+            return HIDDEN;
+        if (tool.name === 'enter_plan_mode' || tool.name === 'exit_plan_mode') {
+            return { shown: 'marker', marker: 'mode', text: tool.name };
+        }
+        if (tool.name === 'kill_command_or_subagent')
+            return names(call.rawInput, this.children.keys()) ? HIDDEN : COMMAND;
+        if (tool.name === 'run_terminal_command')
+            return decidedByLine(call.rawInput?.command, true);
+        return COMMAND;
+    }
+    subagentFinished(_call) {
+        return [];
+    }
+}
+export function answeredFailure(answer) {
+    const failure = answer._meta?.jetbrains?.air?.sessionFailure;
+    return typeof failure?.title === 'string' ? { title: failure.title, limit: failure.category === 'limit' } : null;
+}
+export function readerFor(kind) {
+    if (kind === 'claude-agent-acp')
+        return new ClaudeReader();
+    if (kind === 'grok-build')
+        return new GrokReader();
+    return new CodexReader();
+}

package/dist/files.js

@@ -1,22 +1,128 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { parseDocument } from 'yaml';
+import { retryDelay } from './api.js';
+import { Unsettled } from './mcp.js';
 import { relayed } from './relay.js';
-export async function placeFiles(house, directory, files, signal) {
-    const paths = [];
-    for (const file of files) {
-        const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
-        const answer = await fetch(relayed(original.download.url), { signal });
-        if (!answer.ok)
-            throw new Error(`${file.name} did not download: ${answer.status}`);
-        const folder = join(directory, '.house', 'files', original.message, file.version);
-        await mkdir(join(directory, '.house')).catch((error) => {
-            if (error.code !== 'EEXIST')
+const STALLED_ROUNDS = 8;
+const LINK = /\]\((\/rooms\/[^/)\s]+\/[^)\s]+)\)/gu;
+export function linkedPaths(text) {
+    return [...new Set(Array.from(text.matchAll(LINK), (link) => link[1]))];
+}
+export function inspectedFile(answer) {
+    const document = parseDocument(answer);
+    if (document.errors.length > 0)
+        return null;
+    const inspected = document.toJS();
+    if (typeof inspected?.download !== 'string')
+        return null;
+    return {
+        download: inspected.download,
+        sha256: String(inspected.sha256),
+        media_type: typeof inspected.media_type === 'string' ? inspected.media_type : null,
+    };
+}
+function paused(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export function storeRefusal(act, status) {
+    return new Error(`the ${act} answered ${status}; ${act} the file again`);
+}
+export async function uploaded(declared, uploading) {
+    let upload = declared;
+    let idle = 0;
+    let stalled = 0;
+    for (;;) {
+        let sent = 0;
+        let failure = null;
+        for (const { part, url } of upload.parts) {
+            const start = (part - 1) * upload.part_bytes;
+            try {
+                await uploading.send(url, start, Math.min(start + upload.part_bytes, uploading.bytes));
+                sent++;
+            }
+            catch (error) {
+                failure = error;
+                break;
+            }
+        }
+        if (sent > 0) {
+            idle = 0;
+            stalled = 0;
+        }
+        else {
+            if (failure !== null && ++stalled >= STALLED_ROUNDS)
+                throw failure;
+            // A round that sent no part, its store unreachable or not yet started, is followed by the next finishing call on the jittered curve.
+            await paused(retryDelay(idle++));
+        }
+        let answer = await finishing(uploading, upload.id);
+        while ('checking' in answer) {
+            // A finishing call that finds House still checking the stored bytes is sent again after five seconds, the cadence at which House takes up a check it handed over.
+            await paused(5_000);
+            answer = await finishing(uploading, upload.id);
+        }
+        if (!('upload' in answer))
+            return answer;
+        upload = answer.upload;
+    }
+}
+async function finishing(uploading, upload) {
+    for (let unsettled = 1;; unsettled++) {
+        try {
+            return await uploading.finish(upload);
+        }
+        catch (error) {
+            if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
                 throw error;
+        }
+        // A finishing call House did not settle, unreached or refused short of final, is sent again on the jittered curve as a conversation resends it, so a dropped connection or a House restart resumes the upload instead of ending it.
+        await paused(retryDelay(unsettled - 1));
+    }
+}
+async function drained(body) {
+    for await (const _chunk of body)
+        ;
+}
+export async function downloaded(address, fetching, destination, name) {
+    for (let asked = 1;; asked++) {
+        const { download, sha256 } = await address();
+        const answer = await fetching(download);
+        if (answer.status === 403 && asked === 1) {
+            await drained(answer.body);
+            continue;
+        }
+        if (answer.status !== 200) {
+            await drained(answer.body);
+            throw storeRefusal('download', answer.status);
+        }
+        await mkdir(dirname(destination), { recursive: true });
+        const partial = join(dirname(destination), `.${basename(destination)}.${randomUUID()}`);
+        const digest = createHash('sha256');
+        const hashed = new Transform({
+            transform(chunk, _encoding, done) {
+                digest.update(chunk);
+                done(null, chunk);
+            },
         });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
-        paths.push(path);
+        try {
+            await pipeline(answer.body, hashed, createWriteStream(partial, { flags: 'wx' }));
+            if (digest.digest('hex') !== sha256)
+                throw new Error(`${name} did not arrive whole; download it again`);
+            await rename(partial, destination);
+        }
+        catch (error) {
+            await rm(partial, { force: true });
+            throw error;
+        }
+        return;
     }
-    return paths;
+}
+export async function fetched(url, signal) {
+    const answer = await fetch(relayed(url), { signal });
+    return { status: answer.status, body: answer.body ?? Readable.from([]) };
 }