@agentshouse/kit 0.2.1-cf110d15f69c8 → 0.2.1-cf268dff1869b

package/dist/copies.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { finalRefusal, HouseRefusal, retrying } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
+import { blobId, blobText, git, isText, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
 import { refusalOf } from './refusals.js';
@@ -11,10 +11,13 @@ import { changed } from './translate.js';
 import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
-const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
+const IDENTITY = { GIT_COMMITTER_NAME: 'Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function houseCause(error) {
+    return error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
@@ -29,6 +32,13 @@ const REBASED = new Set([
 function rebaseFixes(refusal) {
     return refusal.code === 'edit_conflict' && refusal.conflicts.some((code) => REBASED.has(code));
 }
+function textOnly(paths) {
+    const [named, them] = paths.length === 1 ? [`${paths[0]} is`, 'it'] : [`${paths.join(', ')} are`, 'them'];
+    return `${named} not text, and house push sends text only; remove ${them} from the commit and place ${them} with house upload`;
+}
+function outside(path) {
+    return { refused: true, text: `${path} is not a House Local copy; run house push inside one` };
+}
 function short(commit) {
     return commit.slice(0, 12);
 }
@@ -48,6 +58,9 @@ function expiredAuthority(error) {
         return undefined;
     }
 }
+function grouped(items, size) {
+    return items.flatMap((_, index) => (index % size === 0 ? [items.slice(index, index + size)] : []));
+}
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
 }
@@ -56,6 +69,9 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
+function recordOf(key) {
+    return join(kitHome(), 'local-copies', `${key}.json`);
+}
 function rootOf(handle) {
     return `/rooms/${handle}`;
 }
@@ -117,7 +133,7 @@ async function ignoreRules(repository, writable, copy) {
     ].map(pattern);
     const granted = readOnly.filter((path) => !protectedPath(path)).map(pattern);
     await ruled(join(repository, '.gitignore'), [
-        '# House Kit writes this file and .ignore. The paths below are read-only House',
+        '# Kit writes this file and .ignore. The paths below are read-only House',
         '# content: Git does not track them, and House refuses a change to them even',
         '# when this file is edited or a path is force-added.',
         '/.gitignore',
@@ -132,7 +148,7 @@ async function ignoreRules(repository, writable, copy) {
         '',
     ].join('\n'));
     await ruled(join(repository, '.ignore'), [
-        '# House Kit writes this file so native search still reads the read-only House',
+        '# Kit writes this file so native search still reads the read-only House',
         '# content that .gitignore keeps out of Git.',
         `!${PROVENANCE}`,
         ...[...house, ...granted].map((rule) => `!${rule}`),
@@ -202,34 +218,45 @@ export class LocalCopies {
     async mapping() {
         await this.answering;
         return [...this.copies.values()]
-            .filter((copy) => copy.active)
+            .filter((copy) => copy.unfollowed === undefined)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    async connected() {
-        const copied = await this.answered(() => this.fetched(false));
-        if (copied.refused)
-            logged(copied.text);
+    connected() {
+        return this.selected();
+    }
+    async changed(rooms) {
+        if (rooms.length > 0)
+            await this.selected(rooms);
     }
     fetch() {
         return this.answered(() => this.fetched(true));
     }
+    async selected(rooms) {
+        const copied = await this.answered(() => this.fetched(false, rooms));
+        if (copied.refused)
+            logged(copied.text);
+    }
     answered(work) {
         const answered = this.answering.then(work);
         this.answering = answered.catch(() => undefined);
         return answered;
     }
-    async fetched(refreshing) {
-        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', {});
+    async fetched(refreshing, rooms) {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', rooms === undefined ? {} : { rooms });
         const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
-        return this.holding([...new Set([...this.copies.keys(), ...synced.keys()])].sort(), async () => {
+        const named = rooms === undefined ? null : new Set(rooms.map((room) => `rooms/${room}`));
+        const held = () => [...this.copies.values()].filter((copy) => named === null || named.has(copy.key));
+        return this.holding([...new Set([...held().map((copy) => copy.key), ...synced.keys()])].sort(), async () => {
             const said = [];
             let refused = false;
-            for (const copy of this.copies.values()) {
-                if (synced.has(copy.key) || !copy.active)
+            const mark = refreshing ? 'said' : 'unsaid';
+            for (const copy of held()) {
+                if (synced.has(copy.key) || copy.unfollowed === 'said' || copy.unfollowed === mark)
                     continue;
-                await this.save({ ...copy, active: false });
-                said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
+                await this.save({ ...copy, unfollowed: mark });
+                if (refreshing)
+                    said.push(`${rootOf(copy.room_handle)}: no longer followed; kept as it is`);
             }
             const current = [];
             for (const [key, handle] of synced) {
@@ -239,11 +266,8 @@ export class LocalCopies {
                         said.push(await this.materialize(key, handle));
                         continue;
                     }
-                    const copy = held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle });
-                    if (copy.active)
-                        current.push(copy);
-                    else
-                        said.push(...moved(copy, await this.save(await this.received({ ...copy, active: true }))));
+                    const { unfollowed, ...followed } = held;
+                    current.push(unfollowed === undefined && held.room_handle === handle ? held : await this.save({ ...followed, room_handle: handle }));
                 }
                 catch (error) {
                     refused = true;
@@ -251,13 +275,12 @@ export class LocalCopies {
                 }
             }
             if (refreshing && current.length > 0) {
-                try {
-                    const refreshed = await this.refreshed(current);
-                    current.forEach((copy, index) => said.push(...moved(copy, refreshed[index])));
-                }
-                catch (error) {
+                const failed = await this.refreshed(current).then(() => null, houseCause);
+                for (const copy of current)
+                    said.push(...moved(copy, this.copies.get(copy.key)));
+                if (failed !== null) {
                     refused = true;
-                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                    said.push(failed);
                 }
             }
             return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
@@ -291,11 +314,11 @@ export class LocalCopies {
     async push(cwd, selector, caller) {
         const located = await run(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
         if (located.status !== 0)
-            return { refused: true, text: `${cwd} is not a House Local copy; run house push inside one` };
+            return outside(cwd);
         const [common, worktree] = located.stdout.toString('utf8').split('\n');
         const key = await this.keyAt(dirname(common));
         if (key === undefined)
-            return { refused: true, text: `${worktree} is not a House Local copy; run house push inside one` };
+            return outside(worktree);
         return this.exclusive(key, () => this.pushed(key, worktree, selector, caller));
     }
     async keyAt(repository) {
@@ -316,7 +339,7 @@ export class LocalCopies {
         return key === undefined ? work() : this.exclusive(key, () => this.holding(rest, work));
     }
     async save(copy) {
-        const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
+        const path = recordOf(copy.key);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -365,7 +388,7 @@ export class LocalCopies {
             throw new Error('House serves nothing of it to copy');
         const repository = join(localCopies(), 'rooms', read.anchor);
         if (await exists(repository))
-            throw new Error(`${repository} already exists and House Kit leaves it as it is`);
+            throw new Error(`${repository} already exists and Kit leaves it as it is`);
         const staging = join(dirname(repository), `.${randomUUID()}`);
         await mkdir(staging, { recursive: true });
         let house;
@@ -390,7 +413,6 @@ export class LocalCopies {
             room_ref: read.anchor,
             room_handle: handle,
             repository,
-            active: true,
             house,
             position: read.position,
             log_epoch: read.log_epoch,
@@ -425,19 +447,24 @@ export class LocalCopies {
         return next;
     }
     async refreshed(copies) {
-        const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: copies.map((copy) => rootOf(copy.room_handle)),
-        });
-        const regranted = new Map();
+        const discover = (group) => this.house.post('/kit/door/discover', { prefixes: group.map((copy) => rootOf(copy.room_handle)) });
+        const [first, ...rest] = copies;
+        const { bounds, authorities } = await discover([first]);
+        for (const group of grouped(rest, bounds.max_prefixes))
+            authorities.push(...(await discover(group)).authorities);
+        const unchanged = [];
         for (const copy of copies) {
-            const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
+            const authority = authorities.find((entry) => entry.room_ref === copy.room_ref);
             if (authority !== undefined &&
                 JSON.stringify([authority.operations.write, authority.protected_paths]) !== JSON.stringify([copy.write, copy.protected])) {
-                regranted.set(copy.key, await this.save(await this.received(copy)));
+                await this.save(await this.received(copy));
+            }
+            else {
+                unchanged.push(copy);
             }
         }
-        const caught = await this.caughtUp(copies.filter((copy) => !regranted.has(copy.key)), false);
-        return copies.map((copy) => regranted.get(copy.key) ?? caught.find((held) => held.key === copy.key));
+        for (const group of grouped(unchanged, bounds.max_prefixes))
+            await this.caughtUp(group, false);
     }
     async caughtUp(copies, whole) {
         const caught = new Map(copies.map((copy) => [copy.key, copy]));
@@ -532,9 +559,6 @@ export class LocalCopies {
             }
             copy = await this.save(without(copy));
         }
-        if (!copy.active) {
-            return { refused: true, text: `${rootOf(copy.room_handle)} is no longer synced to this Environment, so House takes no push from it` };
-        }
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
         if (base === undefined) {
@@ -545,7 +569,7 @@ export class LocalCopies {
             changes = await this.derived(copy, base, commit);
         }
         catch (error) {
-            return { refused: true, text: causeOf(error) };
+            return { refused: true, text: houseCause(error) };
         }
         if (changes.length === 0)
             return { refused: false, text: `Nothing to submit: ${short(commit)} matches House.` };
@@ -572,7 +596,18 @@ export class LocalCopies {
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
         const arrived = new Set(moved.values());
-        const text = (entry, path) => blobText(copy.repository, entry, path);
+        const arriving = [...after].filter(([path, entry]) => before.get(path) !== entry);
+        if (arriving.length > 0) {
+            const { bounds } = await this.house.post('/kit/door/discover', { prefixes: [root] });
+            const binary = [];
+            for (const [path, entry] of arriving) {
+                if (!(await isText(copy.repository, entry, bounds.max_authored_file_bytes)))
+                    binary.push(path);
+            }
+            if (binary.length > 0)
+                throw new Error(textOnly(binary));
+        }
+        const text = (entry) => blobText(copy.repository, entry);
         const changes = [];
         for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {
             if (arrived.has(path))
@@ -585,7 +620,7 @@ export class LocalCopies {
                 changes.push({ op: 'rename', path: `${root}/${path}`, to: `${root}/${to}`, base: known });
                 const moving = after.get(to);
                 if (moving !== prior) {
-                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving, to) });
+                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving) });
                 }
                 continue;
             }
@@ -594,9 +629,9 @@ export class LocalCopies {
             if (next === undefined)
                 changes.push({ op: 'remove', path: `${root}/${path}`, base: known });
             else if (prior === undefined)
-                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next, path) });
+                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next) });
             else
-                changes.push(...changed(`${root}/${path}`, path, known, await text(prior, path), await text(next, path)));
+                changes.push(...changed(`${root}/${path}`, path, known, await text(prior), await text(next)));
         }
         return changes;
     }
@@ -625,8 +660,10 @@ export class LocalCopies {
             }
             if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
-            const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));
+            if (settled.unfollowed !== undefined)
+                return { refused: true, text: outcome.refused.text };
+            const rebased = rebaseFixes(outcome.refused);
             try {
                 settled = (await this.caughtUp([settled], true))[0];
             }
@@ -663,7 +700,7 @@ export class LocalCopies {
             written.push({
                 path: `${root}/${path}`,
                 revision: entry === undefined ? null : (revisionAt(current, current.house, path) ?? null),
-                content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                content: entry === undefined ? null : await blobText(copy.repository, entry),
             });
         }
         return this.finished(await this.save({ ...current, push: { ...push, state: 'accepted', written } }));
@@ -707,7 +744,7 @@ export class LocalCopies {
                     {
                         path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
-                        content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                        content: entry === undefined ? null : await blobText(copy.repository, entry),
                     },
                 ];
             }
@@ -752,7 +789,7 @@ export class LocalCopies {
     async landed(repository, changes, house, selected) {
         const text = async (path) => {
             const entry = house.get(relative(path));
-            return entry === undefined ? undefined : blobText(repository, entry, path);
+            return entry === undefined ? undefined : blobText(repository, entry);
         };
         for (const change of changes) {
             const current = await text(change.path);

package/dist/end.js

@@ -1,17 +1,32 @@
+import { KIT_RELEASE } from './clis.js';
 import { forgetRejected } from './home.js';
+import { installCommand } from './placement.js';
 import { killDescendants } from './scope.js';
-export const REPLACED = 'another Kit started for this Environment';
+export const REPLACED = 'another Kit process started for this Environment';
 function exit(reason, status) {
     process.stderr.write(`kit: ${reason}\n`);
     killDescendants();
     process.exit(status);
 }
 export function end(reason) {
-    exit(reason, 0);
+    exit(reason, process.env.HOUSE_KIT_RESIDENT === String(process.pid) ? 0 : 1);
 }
 export function restart(reason) {
     exit(reason, 1);
 }
+export function updateLine(lead) {
+    const command = installCommand();
+    return command === null ? `${lead}; install it again.` : `${lead}. Update it: ${command}`;
+}
+export function updateRequired() {
+    end(updateLine('This Kit is too old for House'));
+}
+export function unknownMethod(kind) {
+    return updateLine(`This Kit does not know ${kind}`);
+}
+export function newerThanHouse(release, command) {
+    end(`Kit ${KIT_RELEASE} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);
+}
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);
     restart('sign in again');

package/dist/events.js

@@ -1,8 +1,13 @@
+const AUTONOMOUS_ORIGINS = new Set(['task-notification', 'peer', 'coordinator', 'observer', 'observer-activity']);
 const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
 export const RUNNING_JOB = new Set(['running', 'paused']);
-const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
+const MESSAGE_TARGETS = new Map([
+    ['send_routine_request', ['routine', 'agent']],
+    ['cancel_routine_request', ['request']],
+    ['send_mail', ['conversation', 'request']],
+]);
 function words(line) {
     const found = [];
     let word = null;
@@ -48,11 +53,13 @@ export function houseMessage(line) {
     catch {
         return null;
     }
-    const argument = ROUTINE_TARGETS[call.command];
-    if (argument === undefined)
+    if (call === null)
         return null;
-    const target = call.arguments?.[argument];
-    return { shown: 'message', command: call.command, target: typeof target === 'string' ? target : null };
+    const targets = MESSAGE_TARGETS.get(call.command);
+    if (targets === undefined)
+        return null;
+    const target = targets.map((argument) => call.arguments?.[argument]).find((value) => typeof value === 'string');
+    return { shown: 'message', command: call.command, target: target ?? null };
 }
 function decidedByLine(command, final) {
     const line = typeof command === 'string' ? command : Array.isArray(command) ? command.at(-1) : undefined;
@@ -269,6 +276,7 @@ class Reader {
 class ClaudeReader extends Reader {
     watchedOptions = { model: 'model' };
     tasks = new Map();
+    stop = null;
     own(message) {
         if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
             return [];
@@ -276,7 +284,9 @@ class ClaudeReader extends Reader {
     }
     update(update) {
         if (update.sessionUpdate === 'usage_update' && update._meta?.['_claude/origin'] !== undefined) {
-            return [...super.update(update), { kind: 'ended' }];
+            const stop = this.stop;
+            this.stop = null;
+            return [...super.update(update), { kind: 'ended', stop }];
         }
         if (update.sessionUpdate === 'session_info_update' && update._meta?.jetbrains?.air?.sessionFailure !== undefined) {
             return [{ kind: 'marker', marker: 'retry', text: update._meta.jetbrains.air.sessionFailure.title }];
@@ -287,6 +297,13 @@ class ClaudeReader extends Reader {
         if (message.method !== '_claude/sdkMessage')
             return [];
         const sdk = message.params.message;
+        if (sdk.type === 'result') {
+            if (AUTONOMOUS_ORIGINS.has(sdk.origin?.kind))
+                this.stop = null;
+            else
+                this.stop = sdk.stop_reason === 'refusal' ? 'refusal' : sdk.is_error === true ? null : 'end_turn';
+            return [];
+        }
         switch (sdk.subtype) {
             case 'task_started':
                 if (sdk.tool_use_id !== undefined)
@@ -294,6 +311,10 @@ class ClaudeReader extends Reader {
                 return [];
             case 'task_notification':
                 return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            case 'task_progress':
+                if (!this.subagents.has(sdk.tool_use_id) || this.done.has(sdk.tool_use_id) || typeof sdk.description !== 'string')
+                    return [];
+                return [{ kind: 'subagent-activity', id: sdk.tool_use_id, activity: sdk.description }];
             default:
                 return [];
         }
@@ -356,7 +377,7 @@ class CodexReader extends Reader {
                 if (codex?.threadStatus?.type === 'active')
                     return [{ kind: 'started' }];
                 if (codex?.threadStatus?.type === 'idle')
-                    return [{ kind: 'ended' }];
+                    return [{ kind: 'ended', stop: null }];
                 if (codex?.error !== undefined)
                     return [{ kind: 'marker', marker: 'retry', text: codex.error.message ?? '' }];
                 return [];
@@ -429,7 +450,7 @@ class GrokReader extends Reader {
             return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
         }
         if (message.params?.update?.sessionUpdate === 'turn_completed') {
-            return session === this.session ? [{ kind: 'ended' }] : [];
+            return session === this.session ? [{ kind: 'ended', stop: null }] : [];
         }
         if (message.method === '_x.ai/models/update') {
             this.offered(message.params);
@@ -512,6 +533,10 @@ class GrokReader extends Reader {
         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();

package/dist/files.js

@@ -1,36 +1,144 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { HouseRefusal, retrying } from './api.js';
+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 PART_CHECKSUM = 'x-amz-checksum-sha256';
+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`);
+}
+async function partDigests(uploading, partBytes) {
+    const whole = createHash('sha256');
+    const digests = [];
+    for (let start = 0; digests.length === 0 || start < uploading.bytes; start += partBytes) {
+        const end = Math.min(start + partBytes, uploading.bytes);
+        const digest = createHash('sha256');
+        for await (const chunk of uploading.read(start, end)) {
+            digest.update(chunk);
+            whole.update(chunk);
+        }
+        digests.push(digest.digest());
+    }
+    if (whole.digest('hex') !== uploading.sha256)
+        throw new Error(`${uploading.name} changed while it was uploaded; upload it again`);
+    return digests;
+}
+export async function uploaded(declared, uploading) {
+    const partBytes = declared.part_bytes;
+    const digests = await partDigests(uploading, partBytes);
+    const partSha256 = digests.map((digest) => digest.toString('hex'));
+    let answer = await finishing(uploading, declared.id, partSha256);
+    let idle = 0;
+    let stalled = 0;
+    while ('upload' in answer) {
+        const { id, parts } = answer.upload;
+        let sent = 0;
+        let failure = null;
+        for (const { part, url } of parts ?? []) {
+            const start = (part - 1) * partBytes;
+            try {
+                await uploading.send(url, start, Math.min(start + partBytes, uploading.bytes), {
+                    [PART_CHECKSUM]: digests[part - 1].toString('base64'),
+                });
+                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, is followed by the next finishing call on the jittered curve.
+            await paused(retryDelay(idle++));
+        }
+        answer = await finishing(uploading, id, partSha256);
+    }
+    return answer;
+}
+async function finishing(uploading, upload, partSha256) {
+    for (let unsettled = 1;; unsettled++) {
+        try {
+            return await uploading.finish(upload, partSha256);
+        }
+        catch (error) {
+            if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
                 throw error;
-        });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
-        paths.push(path);
+        }
+        // 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));
     }
-    return paths;
-}
-export function uploadBytes(upload, bytes) {
-    return retrying(async () => {
-        const answer = await fetch(relayed(upload.url), {
-            method: 'POST',
-            headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': upload.operation },
-            body: bytes,
+}
+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);
+            },
         });
-        const text = await answer.text();
-        if (!answer.ok)
-            throw new HouseRefusal(upload.url, answer.status, text);
-        return JSON.parse(text);
-    });
+        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;
+    }
+}
+export async function fetched(url, signal) {
+    const answer = await fetch(relayed(url), { signal });
+    return { status: answer.status, body: answer.body ?? Readable.from([]) };
 }