hitloop 0.0.0-stage → 0.1.1

package/dist/fs/notes.js

@@ -0,0 +1,368 @@
+// Notes from the human to the agent: on a file, on lines of it, on an area of a picture, or on nothing in particular
+// ("look at the login flow"), with photos if they like. Kept in .hitl/notes/notes.json, with NOTES.md beside it
+// written for an agent to work through. (These are folderview's review comments, grown up.)
+//
+// Several processes write here (the page through the hub, an agent through the MCP server or the CLI), so every change
+// re-reads the file under a lock, changes it, and writes it back atomically. Each change gets a number (seq), so an
+// agent can read just what's new.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { withLock, writeAtomic } from '../hub/atomic.js';
+const QUOTE_LINES = 12;
+const PHOTO = /^data:image\/(png|jpeg|webp|gif|heic|avif);base64,([A-Za-z0-9+/=]+)$/;
+export class Notes {
+    dir;
+    root;
+    jsonPath;
+    mdPath;
+    comments = [];
+    seq = 0;
+    readSeq = 0;
+    lastWritten = '';
+    listeners = new Set();
+    watcher;
+    constructor(dir, root) {
+        this.dir = dir;
+        this.root = root;
+        this.jsonPath = path.join(dir, 'notes.json');
+        this.mdPath = path.join(dir, 'NOTES.md');
+        this.load();
+    }
+    onChange(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    /** watch notes.json for edits from outside (an agent resolving a note) */
+    watch() {
+        if (this.watcher)
+            return;
+        const start = () => {
+            try {
+                this.watcher = fs.watch(this.dir, (_e, name) => {
+                    if (name && String(name) !== 'notes.json')
+                        return;
+                    setTimeout(() => this.reloadIfChanged(), 60);
+                });
+                this.watcher.on('error', () => undefined);
+            }
+            catch {
+                this.watcher = undefined;
+            }
+        };
+        if (fs.existsSync(this.dir))
+            start();
+        else {
+            const t = setInterval(() => {
+                if (fs.existsSync(this.dir)) {
+                    clearInterval(t);
+                    start();
+                    this.reloadIfChanged();
+                }
+            }, 2000);
+            t.unref();
+        }
+    }
+    close() {
+        this.watcher?.close();
+    }
+    reloadIfChanged() {
+        let text;
+        try {
+            text = fs.readFileSync(this.jsonPath, 'utf8');
+        }
+        catch {
+            text = '';
+        }
+        if (text === this.lastWritten)
+            return;
+        this.load();
+        this.writeMarkdown();
+        this.emit();
+    }
+    emit() {
+        for (const fn of this.listeners)
+            fn();
+    }
+    load() {
+        try {
+            const text = fs.readFileSync(this.jsonPath, 'utf8');
+            this.lastWritten = text;
+            const data = JSON.parse(text);
+            this.comments = Array.isArray(data.comments) ? data.comments.filter(isComment) : [];
+            this.seq = typeof data.seq === 'number' ? data.seq : this.comments.length;
+            this.readSeq = typeof data.readSeq === 'number' ? data.readSeq : 0;
+        }
+        catch {
+            // no file yet, or a half-written hand edit: keep what we had
+        }
+    }
+    /** re-read, change, write: safe with other processes writing too */
+    change(fn) {
+        fs.mkdirSync(this.dir, { recursive: true });
+        return withLock(this.jsonPath, () => {
+            this.load();
+            const r = fn();
+            this.save();
+            return r;
+        });
+    }
+    all() {
+        return this.comments;
+    }
+    /** the change number now, and what the agent has read up to */
+    marks() {
+        this.load();
+        return { seq: this.seq, readSeq: this.readSeq };
+    }
+    /** notes and human replies since the agent last read */
+    unread() {
+        let n = 0;
+        for (const c of this.comments) {
+            if (c.author !== 'agent' && (c.seq ?? 0) > this.readSeq)
+                n++;
+            for (const r of c.replies ?? [])
+                if (r.from !== 'agent' && r.author !== 'agent' && (r.seq ?? 0) > this.readSeq)
+                    n++;
+        }
+        return n;
+    }
+    markRead(upTo) {
+        this.change(() => {
+            this.readSeq = Math.max(this.readSeq, Math.min(upTo ?? this.seq, this.seq));
+        });
+    }
+    add(input) {
+        return this.change(() => {
+            const c = {
+                id: crypto.randomBytes(4).toString('hex'),
+                path: input.path,
+                body: input.body.trim(),
+                author: input.author || 'reviewer',
+                status: 'open',
+                createdAt: new Date().toISOString(),
+                seq: ++this.seq,
+            };
+            if (input.line && input.path) {
+                c.line = input.line;
+                if (input.endLine && input.endLine > input.line)
+                    c.endLine = input.endLine;
+                const quote = this.quote(input.path, input.line, c.endLine ?? input.line);
+                if (quote !== undefined)
+                    c.quote = quote;
+            }
+            if (input.area)
+                c.area = input.area;
+            if (input.strokes?.length)
+                c.strokes = input.strokes;
+            if (input.snapshot) {
+                fs.mkdirSync(path.join(this.dir, 'images'), { recursive: true });
+                c.image = `images/${c.id}.png`;
+                fs.writeFileSync(path.join(this.dir, c.image), input.snapshot);
+            }
+            const photos = [];
+            for (const p of (input.photos ?? []).slice(0, 8)) {
+                const m = PHOTO.exec(p);
+                if (!m)
+                    continue;
+                const buf = Buffer.from(m[2] ?? '', 'base64');
+                if (buf.length > 12 * 1048576)
+                    continue;
+                fs.mkdirSync(path.join(this.dir, 'photos'), { recursive: true });
+                const rel = `photos/${c.id}-${photos.length + 1}.${m[1] === 'jpeg' ? 'jpg' : m[1]}`;
+                fs.writeFileSync(path.join(this.dir, rel), buf);
+                photos.push(rel);
+            }
+            if (photos.length)
+                c.photos = photos;
+            if (input.commit)
+                c.commit = input.commit;
+            this.comments.push(c);
+            return c;
+        });
+    }
+    update(id, patch) {
+        return this.change(() => {
+            const c = this.comments.find((x) => x.id === id);
+            if (!c)
+                return undefined;
+            if (typeof patch.body === 'string' && patch.body.trim()) {
+                c.body = patch.body.trim();
+                c.seq = ++this.seq;
+            }
+            if (patch.status === 'open' || patch.status === 'resolved') {
+                c.status = patch.status;
+                this.seq++;
+            }
+            c.updatedAt = new Date().toISOString();
+            return c;
+        });
+    }
+    reply(id, author, body, from = 'owner') {
+        return this.change(() => {
+            const c = this.comments.find((x) => x.id === id);
+            if (!c || !body.trim())
+                return undefined;
+            (c.replies ??= []).push({ id: crypto.randomBytes(3).toString('hex'), author: author || 'reviewer', from, body: body.trim(), at: new Date().toISOString(), seq: ++this.seq });
+            c.updatedAt = new Date().toISOString();
+            return c;
+        });
+    }
+    /** The agent resolved these notes, saying what it did. */
+    resolve(ids, note, status = 'resolved') {
+        return this.change(() => {
+            const done = [];
+            for (const id of ids) {
+                const c = this.comments.find((x) => x.id === id);
+                if (!c)
+                    continue;
+                c.status = status;
+                if (note.trim())
+                    (c.replies ??= []).push({ id: crypto.randomBytes(3).toString('hex'), author: 'agent', from: 'agent', body: note.trim(), at: new Date().toISOString(), seq: ++this.seq });
+                else
+                    this.seq++;
+                c.updatedAt = new Date().toISOString();
+                done.push(id);
+            }
+            return done;
+        });
+    }
+    remove(id) {
+        return this.change(() => {
+            const gone = this.comments.find((c) => c.id === id);
+            if (!gone)
+                return false;
+            this.comments = this.comments.filter((c) => c.id !== id);
+            this.dropFiles(gone);
+            this.seq++;
+            return true;
+        });
+    }
+    clearResolved() {
+        return this.change(() => {
+            const n = this.comments.length;
+            for (const c of this.comments)
+                if (c.status === 'resolved')
+                    this.dropFiles(c);
+            this.comments = this.comments.filter((c) => c.status !== 'resolved');
+            this.seq++;
+            return n - this.comments.length;
+        });
+    }
+    /** a note's marked-up picture or photo, as a path inside the notes folder (or undefined) */
+    filePath(id, which) {
+        const c = this.comments.find((x) => x.id === id);
+        const rel = which === 'image' ? c?.image : c?.photos?.find((p) => p.endsWith('/' + which) || p === 'photos/' + which);
+        if (!rel || !/^(images|photos)\/[0-9a-f]+(-\d+)?\.(png|jpg|webp|gif|heic|avif)$/.test(rel))
+            return undefined;
+        const abs = path.join(this.dir, rel);
+        return fs.existsSync(abs) ? abs : undefined;
+    }
+    dropFiles(c) {
+        for (const rel of [c.image, ...(c.photos ?? [])])
+            if (rel && /^(images|photos)\/[0-9a-f]+(-\d+)?\.[a-z]+$/.test(rel))
+                fs.rmSync(path.join(this.dir, rel), { force: true });
+    }
+    quote(rel, from, to) {
+        try {
+            const abs = path.join(this.root, rel);
+            if (fs.statSync(abs).size > 5_000_000)
+                return undefined;
+            const lines = fs.readFileSync(abs, 'utf8').split('\n');
+            const end = Math.min(to, from + QUOTE_LINES - 1);
+            const got = lines.slice(from - 1, end).map((l) => l.replace(/\r$/, ''));
+            if (!got.length)
+                return undefined;
+            return got.join('\n') + (to > end ? '\n…' : '');
+        }
+        catch {
+            return undefined;
+        }
+    }
+    save() {
+        fs.mkdirSync(this.dir, { recursive: true });
+        const sorted = [...this.comments].sort((a, b) => a.path.localeCompare(b.path) || (a.line ?? 0) - (b.line ?? 0) || a.createdAt.localeCompare(b.createdAt));
+        const text = JSON.stringify({ version: 1, seq: this.seq, readSeq: this.readSeq, comments: sorted }, null, 2) + '\n';
+        writeAtomic(this.jsonPath, text);
+        this.lastWritten = text;
+        this.writeMarkdown();
+        this.emit();
+    }
+    writeMarkdown() {
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            writeAtomic(this.mdPath, toMarkdown(this.comments, path.relative(this.root, this.jsonPath).split(path.sep).join('/')));
+        }
+        catch {
+            // the folder went away; the next save makes it again
+        }
+    }
+}
+/** What to tell an agent: where the notes are, and how to answer them. */
+export function agentPrompt(mdRel) {
+    return (`Read ${mdRel}: notes from me on files in this project (path:line, the quoted code, and what I said), on areas of pictures, or on nothing in particular. ` +
+        `Work through each open note: make the change it asks for, then resolve it with a short reply saying what you did (\`npx hitloop resolve <id> --note "…"\`, or the resolve tool). ` +
+        `If you can't or shouldn't act on one, leave it open and reply with why. (\`npx hitloop news\` shows what's new.)`);
+}
+export function toMarkdown(comments, jsonRel, { openOnly = false } = {}) {
+    const open = comments.filter((c) => c.status === 'open');
+    const done = openOnly ? [] : comments.filter((c) => c.status === 'resolved');
+    const out = [
+        '# Notes from the human',
+        '',
+        openOnly ? `${open.length} open` : `${open.length} open · ${done.length} resolved · updated ${new Date().toISOString()}`,
+        '',
+        '<!-- Written by hitl. Do not edit this file: it is made from ' + jsonRel + '. -->',
+        '',
+        '## How to work through these (for an agent)',
+        '',
+        '- Each note is on a file, on lines of it (`path:line`), on an area of a picture (marked by hand; `images/<id>.png` beside this file shows the marks), or on nothing in particular. Paths are relative to the project.',
+        '- The quoted code is what the lines said when the note was left; the file may have moved on since, so find the code, not just the line number.',
+        '- When a note is dealt with, resolve it with a reply saying what you did: `npx hitloop resolve <id> --note "Done: …"` (or the MCP tool `resolve`). The human sees it live.',
+        '- Leave notes you could not act on open, with a reply that says why (`npx hitloop reply <id> "…"`).',
+        '',
+    ];
+    const section = (title, list) => {
+        if (!list.length)
+            return;
+        out.push(`## ${title}`, '');
+        let file;
+        for (const c of list) {
+            if (c.path !== file) {
+                file = c.path;
+                out.push(`### ${file || '(not about a particular file)'}`, '');
+            }
+            const where = !c.path ? 'note' : c.line ? `${c.path}:${c.line}${c.endLine ? '-' + c.endLine : ''}` : c.area ? `${c.path} (marked area)` : `${c.path} (whole file)`;
+            out.push(`#### \`${where}\` — ${c.author}${c.commit ? ` @ ${c.commit}` : ''} · id \`${c.id}\``, '');
+            if (c.quote)
+                out.push('```' + langOf(c.path), c.quote, '```', '');
+            if (c.area)
+                out.push(`Marked area: x ${c.area.x}, y ${c.area.y}, ${c.area.w} × ${c.area.h} px of the picture.` + (c.image ? ` The marks are drawn on a copy: ${c.image} (beside this file).` : ''), '');
+            if (c.image)
+                out.push(`![The marked area](${c.image})`, '');
+            for (const p of c.photos ?? [])
+                out.push(`![A photo](${p})`, '');
+            out.push(c.body, '');
+            for (const r of c.replies ?? [])
+                out.push(`> **${r.author}**: ${r.body.replace(/\n/g, '\n> ')}`, '');
+        }
+    };
+    const order = (a, b) => a.path.localeCompare(b.path) || (a.line ?? 0) - (b.line ?? 0);
+    section('Open', [...open].sort(order));
+    section('Resolved', [...done].sort(order));
+    if (!comments.length)
+        out.push('No notes yet.', '');
+    else if (openOnly && !open.length)
+        out.push('No open notes.', '');
+    return out.join('\n');
+}
+function langOf(p) {
+    const ext = p.slice(p.lastIndexOf('.') + 1).toLowerCase();
+    return /^[a-z0-9]{1,8}$/.test(ext) && p.includes('.') ? ext : '';
+}
+function isComment(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const c = x;
+    return typeof c.id === 'string' && typeof c.path === 'string' && typeof c.body === 'string' && (c.status === 'open' || c.status === 'resolved');
+}

package/dist/fs/search.js

@@ -0,0 +1,136 @@
+// The file list (for quick open and name search) and full-text search across it.
+import fs from 'node:fs';
+import path from 'node:path';
+import { isHidden, walk } from './files.js';
+import { pathFilter } from './glob.js';
+const MAX_FILE = 2 * 1024 * 1024;
+const MAX_MATCHES = 3000;
+const MAX_PER_FILE = 200;
+const LINE_CAP = 400;
+export class FileIndex {
+    scope;
+    git;
+    maxFile;
+    cached;
+    constructor(scope, git, maxFile = MAX_FILE) {
+        this.scope = scope;
+        this.git = git;
+        this.maxFile = maxFile;
+    }
+    invalidate() {
+        this.cached = undefined;
+    }
+    async files() {
+        if (this.cached && Date.now() - this.cached.at < 30_000)
+            return this.cached.files;
+        let files;
+        if (this.git)
+            files = await this.git.files().catch(() => undefined);
+        files ??= walk(this.scope);
+        files = files.filter((f) => !f.split('/').some((p) => isHidden(this.scope, p)) && !this.scope.excluded(f) && fs.existsSync(path.join(this.scope.root, f)));
+        this.cached = { at: Date.now(), files };
+        return files;
+    }
+    async search(query) {
+        const t0 = Date.now();
+        const result = { files: [], total: 0, truncated: false, searched: 0, ms: 0 };
+        let re;
+        try {
+            re = makeRegex(query);
+        }
+        catch (e) {
+            return { ...result, error: e instanceof Error ? e.message : String(e) };
+        }
+        const prefix = query.scope.replace(/^\/+|\/+$/g, '');
+        const filter = pathFilter(query.include);
+        const all = (await this.files()).filter((f) => (!prefix || f.startsWith(prefix + '/')) && filter(f));
+        // in git, git grep says which files can match; only those are read (names are still checked on every file)
+        const maybe = this.git ? await this.git.grepFiles(query.q, { regex: query.regex, caseSensitive: query.caseSensitive, word: query.word }) : undefined;
+        // read many files at once (each read is mostly waiting on the disk), keep the results in path order
+        const found = new Array(all.length);
+        let next = 0;
+        const worker = async () => {
+            while (next < all.length && result.total < MAX_MATCHES) {
+                const idx = next++;
+                const file = all[idx] ?? '';
+                const hits = { path: file, matches: [] };
+                re.lastIndex = 0;
+                if (re.test(file.slice(file.lastIndexOf('/') + 1)))
+                    hits.name = true;
+                const text = maybe && !maybe.has(file) ? undefined : await readText(path.join(this.scope.root, file), this.maxFile);
+                if (maybe && !maybe.has(file))
+                    result.searched++;
+                if (text !== undefined) {
+                    result.searched++;
+                    const lines = text.split('\n');
+                    for (let i = 0; i < lines.length && hits.matches.length < MAX_PER_FILE; i++) {
+                        const line = (lines[i] ?? '').replace(/\r$/, '');
+                        const ranges = hitsIn(re, line);
+                        if (ranges.length)
+                            hits.matches.push(clip(i + 1, line, ranges));
+                    }
+                }
+                if (hits.matches.length || hits.name) {
+                    found[idx] = hits;
+                    result.total += hits.matches.length || 1;
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: 48 }, worker));
+        result.truncated = next < all.length;
+        result.files = found.filter((f) => f !== undefined);
+        result.ms = Date.now() - t0;
+        return result;
+    }
+}
+function makeRegex(q) {
+    let src = q.regex ? q.q : q.q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (q.word)
+        src = `\\b(?:${src})\\b`;
+    const re = new RegExp(src, q.caseSensitive ? 'g' : 'gi');
+    if (re.test(''))
+        throw new Error('That pattern matches nothing at all (an empty match).');
+    return re;
+}
+function hitsIn(re, line) {
+    const out = [];
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(line)) && out.length < 50) {
+        if (m[0] === '') {
+            re.lastIndex++;
+            continue;
+        }
+        out.push([m.index, m.index + m[0].length]);
+    }
+    return out;
+}
+/** long lines are cut around the first hit so the result stays readable */
+function clip(line, text, hits) {
+    if (text.length <= LINE_CAP)
+        return { line, text, hits };
+    const first = hits[0]?.[0] ?? 0;
+    const start = Math.max(0, first - 80);
+    const end = Math.min(text.length, start + LINE_CAP);
+    const lead = start > 0 ? '…' : '';
+    const shift = start - lead.length;
+    return {
+        line,
+        text: lead + text.slice(start, end) + (end < text.length ? '…' : ''),
+        hits: hits.filter(([a, b]) => a >= start && b <= end).map(([a, b]) => [a - shift, b - shift]),
+    };
+}
+async function readText(abs, max) {
+    try {
+        const st = await fs.promises.stat(abs);
+        if (!st.isFile() || st.size > max)
+            return undefined;
+        const buf = await fs.promises.readFile(abs);
+        if (buf.subarray(0, 8192).includes(0))
+            return undefined; // binary
+        return buf.toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/fs/watch.js

@@ -0,0 +1,69 @@
+// Live reload: watches the folder and tells open pages which folders changed (and when git's state may have).
+import fs from 'node:fs';
+import path from 'node:path';
+import { NOISE } from './files.js';
+export function watchTree(root, gitDir, onBatch) {
+    let folders = new Set(), files = new Set(), git = false;
+    let timer;
+    const flush = () => {
+        timer = undefined;
+        const b = { folders: [...folders], files: [...files], git };
+        folders = new Set();
+        files = new Set();
+        git = false;
+        onBatch(b);
+    };
+    const bump = () => {
+        timer ??= setTimeout(flush, 250);
+    };
+    const closers = [];
+    try {
+        const w = fs.watch(root, { recursive: true }, (_event, name) => {
+            if (!name)
+                return bump();
+            const rel = String(name).split(path.sep).join('/');
+            const parts = rel.split('/');
+            if (parts[0] === '.git') {
+                // the index, HEAD and refs say git's view moved; objects and logs are noise
+                if (/^\.git\/(index|HEAD|refs\/|packed-refs|MERGE_HEAD)/.test(rel)) {
+                    git = true;
+                    bump();
+                }
+                return;
+            }
+            if (parts.some((p) => NOISE.has(p)))
+                return;
+            files.add(rel);
+            folders.add(parts.slice(0, -1).join('/'));
+            git = true; // a working-tree edit changes git status too
+            bump();
+        });
+        w.on('error', () => undefined);
+        closers.push(() => w.close());
+    }
+    catch {
+        // recursive watching isn't available here: no live reload, the page still works on refresh
+    }
+    // a served subfolder of a repo: .git is elsewhere, watch it on its own
+    if (gitDir && !gitDir.startsWith(root + path.sep)) {
+        try {
+            const w = fs.watch(gitDir, (_e, name) => {
+                if (name && /^(index|HEAD|packed-refs)$/.test(String(name))) {
+                    git = true;
+                    bump();
+                }
+            });
+            w.on('error', () => undefined);
+            closers.push(() => w.close());
+        }
+        catch {
+            // fine without it
+        }
+    }
+    return () => {
+        for (const c of closers)
+            c();
+        if (timer)
+            clearTimeout(timer);
+    };
+}

package/dist/fs/zip.js

@@ -0,0 +1,100 @@
+// A folder as a .zip, streamed: each file deflated (or stored, when that's smaller), no dependencies.
+// Plain ZIP (not ZIP64): up to 65,535 files and under 4 GB, which is checked before anything is sent.
+import fs from 'node:fs';
+import path from 'node:path';
+import zlib from 'node:zlib';
+const TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+export function crc32(buf) {
+    const native = zlib.crc32;
+    if (native)
+        return native(buf) >>> 0;
+    let c = 0xffffffff;
+    for (const b of buf)
+        c = (TABLE[(c ^ b) & 0xff] ?? 0) ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+export const ZIP_LIMITS = { files: 65_535, bytes: 2 * 1024 * 1024 * 1024 };
+function dosTime(d) {
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
+    const date = (Math.max(0, d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+    return [time, date];
+}
+/** Write a zip of the given files (absolute path → name inside the zip) to out. */
+export async function writeZip(out, files) {
+    const central = [];
+    let offset = 0;
+    const write = (b) => new Promise((resolve, reject) => {
+        offset += b.length;
+        if (out.write(b))
+            resolve();
+        else {
+            out.once('drain', resolve);
+            out.once('error', reject);
+        }
+    });
+    for (const f of files) {
+        let data, st;
+        try {
+            st = await fs.promises.stat(f.abs);
+            data = await fs.promises.readFile(f.abs);
+        }
+        catch {
+            continue; // gone since it was listed
+        }
+        const crc = crc32(data);
+        const deflated = zlib.deflateRawSync(data, { level: 6 });
+        const store = deflated.length >= data.length;
+        const body = store ? data : deflated;
+        const name = Buffer.from(f.name, 'utf8');
+        const [time, date] = dosTime(st.mtime);
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0x0800, 6); // names are UTF-8
+        local.writeUInt16LE(store ? 0 : 8, 8);
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(date, 12);
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(body.length, 18);
+        local.writeUInt32LE(data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        const at = offset;
+        await write(Buffer.concat([local, name]));
+        await write(body);
+        const cen = Buffer.alloc(46);
+        cen.writeUInt32LE(0x02014b50, 0);
+        cen.writeUInt16LE(20, 4);
+        cen.writeUInt16LE(20, 6);
+        cen.writeUInt16LE(0x0800, 8);
+        cen.writeUInt16LE(store ? 0 : 8, 10);
+        cen.writeUInt16LE(time, 12);
+        cen.writeUInt16LE(date, 14);
+        cen.writeUInt32LE(crc, 16);
+        cen.writeUInt32LE(body.length, 20);
+        cen.writeUInt32LE(data.length, 24);
+        cen.writeUInt16LE(name.length, 28);
+        cen.writeUInt32LE(at, 42);
+        central.push(Buffer.concat([cen, name]));
+    }
+    const start = offset;
+    const dir = Buffer.concat(central);
+    await write(dir);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(central.length, 8);
+    end.writeUInt16LE(central.length, 10);
+    end.writeUInt32LE(dir.length, 12);
+    end.writeUInt32LE(start, 16);
+    await write(end);
+}
+/** A zip-safe name for a root-relative path inside a folder being zipped. */
+export const entryName = (folderName, rel) => path.posix.join(folderName, rel);