@volter/world-core 2.0.0

package/dist/src/git/history.js

@@ -0,0 +1,298 @@
+// HISTORY AND DIFF: what a hosting twin's REST plane asks of the object store beyond raw reads —
+// the merge base of two commits, the changed-file list between two commits with GitHub's
+// three-dot semantics (merge-base(base, head)..head), per-file addition/deletion counts and a
+// unified patch from a Myers line diff. Pure functions of the store; the `git` binary is the
+// oracle these were proven against, never a dependency.
+import { decodeCommit, decodeTree } from "./objects.js";
+async function parentsOf(store, sha) { const o = await store.read(sha); return o?.type === 'commit' ? decodeCommit(o.payload).parents : []; }
+/** Ancestors of `sha` (inclusive), bounded. */
+async function ancestors(store, sha, limit) {
+    const seen = new Set();
+    const stack = [sha];
+    while (stack.length && seen.size < limit) {
+        const s = stack.pop();
+        if (seen.has(s))
+            continue;
+        seen.add(s);
+        stack.push(...(await parentsOf(store, s)));
+    }
+    return seen;
+}
+/** A best common ancestor of `a` and `b` (one that is not an ancestor of another common ancestor), or null. */
+export async function mergeBase(store, a, b, limit = 20000) {
+    if (!(await store.has(a)) || !(await store.has(b)))
+        return null;
+    const ofA = await ancestors(store, a, limit);
+    // BFS from b in parent order: the first commits reached that lie in A's ancestry are candidates; a
+    // candidate reached through another candidate is dominated and dropped.
+    const candidates = [];
+    const seen = new Set();
+    const queue = [b];
+    while (queue.length && seen.size < limit) {
+        const s = queue.shift();
+        if (seen.has(s))
+            continue;
+        seen.add(s);
+        if (ofA.has(s)) {
+            candidates.push(s);
+            continue;
+        }
+        queue.push(...(await parentsOf(store, s)));
+    }
+    if (candidates.length === 0)
+        return null;
+    if (candidates.length === 1)
+        return candidates[0];
+    const dominated = new Set();
+    for (const c of candidates) {
+        const anc = await ancestors(store, c, limit);
+        for (const d of candidates)
+            if (d !== c && anc.has(d))
+                dominated.add(d);
+    }
+    return candidates.find((c) => !dominated.has(c)) ?? candidates[0];
+}
+async function treeOf(store, sha) {
+    const o = await store.read(sha);
+    if (!o)
+        return [];
+    if (o.type === 'commit')
+        return treeOf(store, decodeCommit(o.payload).tree);
+    return o.type === 'tree' ? decodeTree(o.payload) : [];
+}
+const isDir = (m) => m === '40000' || m === '040000';
+/** Recursive tree compare between two commits or trees (paths in the post-image order, no rename pairing — like `diff-tree -r` without -M). */
+export async function diffTrees(store, from, to, prefix = '') {
+    const a = from ? await treeOf(store, from) : [];
+    const b = await treeOf(store, to);
+    const byName = new Map(a.map((e) => [e.name, e]));
+    const out = [];
+    const seenNames = new Set();
+    const all = [...a.map((e) => e.name), ...b.map((e) => e.name)].filter((n) => (seenNames.has(n) ? false : (seenNames.add(n), true))).sort();
+    const bByName = new Map(b.map((e) => [e.name, e]));
+    for (const name of all) {
+        const ax = byName.get(name), by = bByName.get(name);
+        const path = prefix + name;
+        if (ax && by && ax.sha === by.sha && ax.mode === by.mode)
+            continue;
+        const xd = ax ? isDir(ax.mode) : false, yd = by ? isDir(by.mode) : false;
+        if (xd || yd) {
+            if (xd && yd)
+                out.push(...(await diffTrees(store, ax.sha, by.sha, `${path}/`)));
+            else {
+                if (xd)
+                    out.push(...(await diffTrees(store, ax.sha, '4b825dc642cb6eb9a060e54bf8d69288fbee4904', `${path}/`)).map((c) => ({ ...c })));
+                else if (ax)
+                    out.push({ path, status: 'removed', oldSha: ax.sha, oldMode: ax.mode });
+                if (yd)
+                    out.push(...(await diffTrees(store, null, by.sha, `${path}/`)));
+                else if (by)
+                    out.push({ path, status: 'added', newSha: by.sha, newMode: by.mode });
+            }
+            continue;
+        }
+        if (ax && by)
+            out.push({ path, status: 'modified', oldSha: ax.sha, newSha: by.sha, oldMode: ax.mode, newMode: by.mode });
+        else if (ax)
+            out.push({ path, status: 'removed', oldSha: ax.sha, oldMode: ax.mode });
+        else if (by)
+            out.push({ path, status: 'added', newSha: by.sha, newMode: by.mode });
+    }
+    return out;
+}
+function splitLines(text) { if (text === '')
+    return []; const lines = text.split('\n'); if (lines[lines.length - 1] === '')
+    lines.pop(); return lines; }
+/** A shortest edit script between two texts (Myers, O((N+M)D)). */
+export function lineDiff(oldText, newText) {
+    const a = splitLines(oldText), b = splitLines(newText);
+    const n = a.length, m = b.length;
+    const max = n + m;
+    const v = new Map([[1, 0]]);
+    const trace = [];
+    outer: for (let d = 0; d <= max; d++) {
+        trace.push(new Map(v));
+        for (let k = -d; k <= d; k += 2) {
+            let ax = k === -d || (k !== d && (v.get(k - 1) ?? 0) < (v.get(k + 1) ?? 0)) ? (v.get(k + 1) ?? 0) : (v.get(k - 1) ?? 0) + 1;
+            let by = ax - k;
+            while (ax < n && by < m && a[ax] === b[by]) {
+                ax++;
+                by++;
+            }
+            v.set(k, ax);
+            if (ax >= n && by >= m)
+                break outer;
+        }
+    }
+    const edits = [];
+    let ax = n, by = m;
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const vv = trace[d];
+        const k = ax - by;
+        const prevK = k === -d || (k !== d && (vv.get(k - 1) ?? 0) < (vv.get(k + 1) ?? 0)) ? k + 1 : k - 1;
+        const prevX = vv.get(prevK) ?? 0;
+        const prevY = prevX - prevK;
+        while (ax > prevX && by > prevY) {
+            edits.push({ kind: ' ', line: a[ax - 1] });
+            ax--;
+            by--;
+        }
+        if (d > 0) {
+            if (ax === prevX) {
+                edits.push({ kind: '+', line: b[by - 1] });
+                by--;
+            }
+            else {
+                edits.push({ kind: '-', line: a[ax - 1] });
+                ax--;
+            }
+        }
+    }
+    return edits.reverse();
+}
+/** The unified-diff hunks (the body GitHub serves as a file's `patch`), 3 lines of context. */
+export function unifiedPatch(oldText, newText, context = 3) {
+    const edits = lineDiff(oldText, newText);
+    if (!edits.some((e) => e.kind !== ' '))
+        return '';
+    const oldNoNl = oldText !== '' && !oldText.endsWith('\n'), newNoNl = newText !== '' && !newText.endsWith('\n');
+    const oldLines = splitLines(oldText).length, newLines = splitLines(newText).length;
+    // group edits into hunks: a run of changes with up to `context` unchanged lines around it
+    const hunks = [];
+    let i = 0;
+    while (i < edits.length) {
+        if (edits[i].kind === ' ') {
+            i++;
+            continue;
+        }
+        const start = Math.max(0, i - context);
+        let end = i;
+        while (end < edits.length) {
+            if (edits[end].kind !== ' ') {
+                end++;
+                continue;
+            }
+            let run = end;
+            while (run < edits.length && edits[run].kind === ' ')
+                run++;
+            if (run - end > context * 2 || run >= edits.length) {
+                end = Math.min(edits.length, end + context);
+                break;
+            }
+            end = run;
+        }
+        hunks.push({ start, end });
+        i = end;
+    }
+    let oldPos = 0, newPos = 0, out = '';
+    let cursor = 0;
+    for (const h of hunks) {
+        for (; cursor < h.start; cursor++) {
+            const e = edits[cursor];
+            if (e.kind !== '+')
+                oldPos++;
+            if (e.kind !== '-')
+                newPos++;
+        }
+        let oc = 0, nc = 0, body = '';
+        for (let j = h.start; j < h.end; j++) {
+            const e = edits[j];
+            body += `${e.kind}${e.line}\n`;
+            const lastOld = e.kind !== '+' && oldPos + oc === oldLines - 1, lastNew = e.kind !== '-' && newPos + nc === newLines - 1;
+            if (e.kind !== '+')
+                oc++;
+            if (e.kind !== '-')
+                nc++;
+            if ((e.kind === '-' && lastOld && oldNoNl) || (e.kind === '+' && lastNew && newNoNl) || (e.kind === ' ' && lastOld && oldNoNl && lastNew && newNoNl))
+                body += '\\n';
+        }
+        const range = (p, c) => (c === 1 ? `${p + 1}` : `${c === 0 ? p : p + 1},${c}`);
+        out += `@@ -${range(oldPos, oc)} +${range(newPos, nc)} @@\n${body}`;
+        oldPos += oc;
+        newPos += nc;
+        cursor = h.end;
+    }
+    return out.replace(/\n$/, '');
+}
+const DEC = new TextDecoder();
+function looksBinary(bytes) { const n = Math.min(bytes.length, 8000); for (let i = 0; i < n; i++)
+    if (bytes[i] === 0)
+        return true; return false; }
+/** GitHub's file list between `base` and `head` (three-dot: from merge-base(base, head), or base when histories are unrelated), with counts and patches. */
+export async function diffFiles(store, baseSha, headSha, opts = {}) {
+    if (!(await store.has(baseSha)) || !(await store.has(headSha)))
+        return null;
+    const from = (await mergeBase(store, baseSha, headSha)) ?? baseSha;
+    const out = [];
+    for (const c of await diffTrees(store, from, headSha)) {
+        const oldB = c.oldSha ? (await store.read(c.oldSha))?.payload ?? new Uint8Array() : new Uint8Array();
+        const newB = c.newSha ? (await store.read(c.newSha))?.payload ?? new Uint8Array() : new Uint8Array();
+        const file = { filename: c.path, status: c.status, additions: 0, deletions: 0, ...(c.newSha ? { sha: c.newSha } : {}) };
+        if (!looksBinary(oldB) && !looksBinary(newB)) {
+            const oldT = DEC.decode(oldB), newT = DEC.decode(newB);
+            const edits = lineDiff(oldT, newT);
+            file.additions = edits.filter((e) => e.kind === '+').length;
+            file.deletions = edits.filter((e) => e.kind === '-').length;
+            if (opts.patch) {
+                const p = unifiedPatch(oldT, newT);
+                if (p)
+                    file.patch = p;
+            }
+        }
+        out.push(file);
+    }
+    return out;
+}
+/** Three-way line merge. Return null for overlapping edits; preserve exact line endings.
+ * Binary payloads belong to the caller's conflict path, never a text decoder's replacement. */
+export function mergeText(base, ours, theirs) {
+    if (ours === theirs || theirs === base)
+        return ours;
+    if (ours === base)
+        return theirs;
+    // Encode whole lines, including their terminators, before diffing. Thus changing the final
+    // newline is a real edit and CRLF bytes survive without a separate post-merge guess.
+    const lines = (text) => (text.match(/[^\n]*\n|[^\n]+$/g) ?? []).map(s => JSON.stringify(s));
+    const original = lines(base);
+    const changes = (text) => {
+        const out = [];
+        let cursor = 0;
+        let hunk;
+        for (const edit of lineDiff(original.join('\n'), lines(text).join('\n'))) {
+            if (edit.kind === ' ') {
+                hunk = undefined;
+                cursor++;
+                continue;
+            }
+            if (!hunk) {
+                hunk = { start: cursor, end: cursor, lines: [] };
+                out.push(hunk);
+            }
+            if (edit.kind === '-') {
+                cursor++;
+                hunk.end++;
+            }
+            else
+                hunk.lines.push(edit.line);
+        }
+        return out;
+    };
+    const left = changes(ours), right = changes(theirs);
+    const identical = (a, b) => a.start === b.start && a.end === b.end && JSON.stringify(a.lines) === JSON.stringify(b.lines);
+    const edits = [...left];
+    for (const b of right) {
+        if (left.some(a => identical(a, b)))
+            continue;
+        for (const a of left) {
+            // Two insertions at one point or touching changed intervals have ambiguous order.
+            if (a.start <= b.end && b.start <= a.end)
+                return null;
+        }
+        edits.push(b);
+    }
+    edits.sort((a, b) => b.start - a.start);
+    const result = [...original];
+    for (const h of edits)
+        result.splice(h.start, h.end - h.start, ...h.lines);
+    return result.map(line => JSON.parse(line)).join('');
+}

package/dist/src/git/index.d.ts

@@ -0,0 +1,6 @@
+export * from './inflate.js';
+export * from './objects.js';
+export * from './pack.js';
+export * from './refs.js';
+export * from './smart-http.js';
+export * from './history.js';

package/dist/src/git/index.js

@@ -0,0 +1,6 @@
+export * from "./inflate.js";
+export * from "./objects.js";
+export * from "./pack.js";
+export * from "./refs.js";
+export * from "./smart-http.js";
+export * from "./history.js";

package/dist/src/git/inflate.d.ts

@@ -0,0 +1,11 @@
+/** Raw DEFLATE (RFC 1951) starting at `offset`: the bytes out and the input consumed. */
+export declare function inflateRaw(input: Uint8Array, offset?: number): {
+    out: Uint8Array;
+    consumed: number;
+};
+export declare function adler32(bytes: Uint8Array): number;
+/** zlib (RFC 1950) starting at `offset`: header checked, Adler-32 verified, consumed includes both. */
+export declare function inflateZlib(input: Uint8Array, offset?: number): {
+    out: Uint8Array;
+    consumed: number;
+};

package/dist/src/git/inflate.js

@@ -0,0 +1,194 @@
+// A pure-JS zlib INFLATE that reports the bytes it consumed — the one thing the standard
+// DecompressionStream cannot say, and the one thing a packfile reader must know (each object's
+// zlib stream is followed by the next object's header with no length in between). Stored,
+// fixed-Huffman and dynamic-Huffman blocks (RFC 1951) inside a zlib wrapper (RFC 1950: a 2-byte
+// header, an Adler-32 trailer). No dependency; runs on Bun and workerd alike.
+const LENGTH_BASE = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const DIST_BASE = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DIST_EXTRA = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+const CL_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function buildHuffman(lengths, n) {
+    const counts = new Uint16Array(16);
+    const symbols = new Uint16Array(n);
+    for (let i = 0; i < n; i++)
+        counts[lengths[i]]++;
+    counts[0] = 0;
+    const offs = new Uint16Array(16);
+    for (let i = 1; i < 16; i++)
+        offs[i] = offs[i - 1] + counts[i - 1];
+    for (let i = 0; i < n; i++)
+        if (lengths[i])
+            symbols[offs[lengths[i]]++] = i;
+    return { counts, symbols };
+}
+class BitReader {
+    input;
+    pos;
+    bitBuf = 0;
+    bitCount = 0;
+    constructor(input, offset) {
+        this.input = input;
+        this.pos = offset;
+    }
+    bit() {
+        if (this.bitCount === 0) {
+            if (this.pos >= this.input.length)
+                throw new Error('inflate: unexpected end of input');
+            this.bitBuf = this.input[this.pos++];
+            this.bitCount = 8;
+        }
+        const b = this.bitBuf & 1;
+        this.bitBuf >>>= 1;
+        this.bitCount--;
+        return b;
+    }
+    bits(n) { let v = 0; for (let i = 0; i < n; i++)
+        v |= this.bit() << i; return v; }
+    symbol(h) {
+        let code = 0, first = 0, index = 0;
+        for (let len = 1; len < 16; len++) {
+            code |= this.bit();
+            const count = h.counts[len];
+            if (code - count < first)
+                return h.symbols[index + (code - first)];
+            index += count;
+            first += count;
+            first <<= 1;
+            code <<= 1;
+        }
+        throw new Error('inflate: bad huffman code');
+    }
+    alignByte() { this.bitBuf = 0; this.bitCount = 0; }
+}
+class Out {
+    buf = new Uint8Array(1 << 16);
+    len = 0;
+    push(b) { if (this.len === this.buf.length) {
+        const n = new Uint8Array(this.buf.length * 2);
+        n.set(this.buf);
+        this.buf = n;
+    } this.buf[this.len++] = b; }
+    copy(dist, length) { if (dist > this.len)
+        throw new Error('inflate: distance too far back'); for (let i = 0; i < length; i++)
+        this.push(this.buf[this.len - dist]); }
+    // A right-sized copy: a view would pin the whole (>= 64 KiB, doubling) scratch buffer behind
+    // every inflated object, which is what a 105k-object push cost the github twin (~7 GB).
+    bytes() { return this.buf.slice(0, this.len); }
+}
+let FIXED;
+function fixedTables() {
+    if (FIXED)
+        return FIXED;
+    const l = new Uint8Array(288);
+    for (let i = 0; i < 144; i++)
+        l[i] = 8;
+    for (let i = 144; i < 256; i++)
+        l[i] = 9;
+    for (let i = 256; i < 280; i++)
+        l[i] = 7;
+    for (let i = 280; i < 288; i++)
+        l[i] = 8;
+    const d = new Uint8Array(30).fill(5);
+    FIXED = { lit: buildHuffman(l, 288), dist: buildHuffman(d, 30) };
+    return FIXED;
+}
+function inflateBlockData(r, out, lit, dist) {
+    for (;;) {
+        const sym = r.symbol(lit);
+        if (sym < 256)
+            out.push(sym);
+        else if (sym === 256)
+            return;
+        else {
+            const li = sym - 257;
+            if (li >= 29)
+                throw new Error('inflate: bad length symbol');
+            const length = LENGTH_BASE[li] + r.bits(LENGTH_EXTRA[li]);
+            const di = r.symbol(dist);
+            if (di >= 30)
+                throw new Error('inflate: bad distance symbol');
+            out.copy(DIST_BASE[di] + r.bits(DIST_EXTRA[di]), length);
+        }
+    }
+}
+function inflateDynamic(r, out) {
+    const hlit = r.bits(5) + 257, hdist = r.bits(5) + 1, hclen = r.bits(4) + 4;
+    const cl = new Uint8Array(19);
+    for (let i = 0; i < hclen; i++)
+        cl[CL_ORDER[i]] = r.bits(3);
+    const clh = buildHuffman(cl, 19);
+    const lengths = new Uint8Array(hlit + hdist);
+    for (let i = 0; i < hlit + hdist;) {
+        const sym = r.symbol(clh);
+        if (sym < 16)
+            lengths[i++] = sym;
+        else if (sym === 16) {
+            if (i === 0)
+                throw new Error('inflate: repeat with no previous length');
+            const prev = lengths[i - 1];
+            for (let n = 3 + r.bits(2); n > 0; n--)
+                lengths[i++] = prev;
+        }
+        else if (sym === 17) {
+            for (let n = 3 + r.bits(3); n > 0; n--)
+                lengths[i++] = 0;
+        }
+        else {
+            for (let n = 11 + r.bits(7); n > 0; n--)
+                lengths[i++] = 0;
+        }
+    }
+    inflateBlockData(r, out, buildHuffman(lengths.subarray(0, hlit), hlit), buildHuffman(lengths.subarray(hlit), hdist));
+}
+/** Raw DEFLATE (RFC 1951) starting at `offset`: the bytes out and the input consumed. */
+export function inflateRaw(input, offset = 0) {
+    const r = new BitReader(input, offset);
+    const out = new Out();
+    let final = 0;
+    do {
+        final = r.bit();
+        const type = r.bits(2);
+        if (type === 0) {
+            r.alignByte();
+            const len = input[r.pos] | (input[r.pos + 1] << 8);
+            const nlen = input[r.pos + 2] | (input[r.pos + 3] << 8);
+            if ((len ^ 0xffff) !== nlen)
+                throw new Error('inflate: stored block length mismatch');
+            r.pos += 4;
+            for (let i = 0; i < len; i++)
+                out.push(input[r.pos++]);
+        }
+        else if (type === 1) {
+            const t = fixedTables();
+            inflateBlockData(r, out, t.lit, t.dist);
+        }
+        else if (type === 2)
+            inflateDynamic(r, out);
+        else
+            throw new Error('inflate: reserved block type');
+    } while (!final);
+    return { out: out.bytes(), consumed: r.pos - offset };
+}
+export function adler32(bytes) {
+    let a = 1, b = 0;
+    for (let i = 0; i < bytes.length; i++) {
+        a = (a + bytes[i]) % 65521;
+        b = (b + a) % 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+/** zlib (RFC 1950) starting at `offset`: header checked, Adler-32 verified, consumed includes both. */
+export function inflateZlib(input, offset = 0) {
+    const cmf = input[offset], flg = input[offset + 1];
+    if ((cmf & 0x0f) !== 8 || ((cmf << 8) | flg) % 31 !== 0)
+        throw new Error('inflate: not a zlib stream');
+    if (flg & 0x20)
+        throw new Error('inflate: preset dictionary is not supported');
+    const { out, consumed } = inflateRaw(input, offset + 2);
+    const t = offset + 2 + consumed;
+    const expected = ((input[t] << 24) | (input[t + 1] << 16) | (input[t + 2] << 8) | input[t + 3]) >>> 0;
+    if (expected !== adler32(out))
+        throw new Error('inflate: adler32 mismatch');
+    return { out, consumed: consumed + 6 };
+}

package/dist/src/git/objects.d.ts

@@ -0,0 +1,64 @@
+import type { BlobStore } from '../blob-store.js';
+export type GitObjectType = 'commit' | 'tree' | 'blob' | 'tag';
+export declare function sha1Hex(bytes: Uint8Array): Promise<string>;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(b: Uint8Array): string;
+export declare function concat(...parts: Uint8Array[]): Uint8Array;
+/** The loose-object form: header + payload (what the sha is computed over). */
+export declare function encodeLoose(type: GitObjectType, payload: Uint8Array): Uint8Array;
+export declare function decodeLoose(bytes: Uint8Array): {
+    type: GitObjectType;
+    payload: Uint8Array;
+};
+export declare function hashObject(type: GitObjectType, payload: Uint8Array): Promise<string>;
+export declare function deflateZlib(bytes: Uint8Array): Promise<Uint8Array>;
+/** zlib with stored (uncompressed) deflate blocks: what git writes at `core.compression 0`, and what every
+ *  inflater reads. A loose object is written on every commit a World makes; compressing each one through the
+ *  asynchronous CompressionStream made a write's cost the stream's round trips, not the object's size. */
+export declare function storeZlib(bytes: Uint8Array): Uint8Array;
+/** The object store: one bare repo's objects under a key prefix in the blob seam. */
+export declare class GitObjectStore {
+    private readonly blobs;
+    private readonly prefix;
+    constructor(blobs: BlobStore, prefix: string);
+    key(sha: string): string;
+    has(sha: string): Promise<boolean>;
+    write(type: GitObjectType, payload: Uint8Array): Promise<string>;
+    read(sha: string): Promise<{
+        type: GitObjectType;
+        payload: Uint8Array;
+    } | null>;
+}
+export type TreeEntry = {
+    mode: string;
+    name: string;
+    sha: string;
+};
+/** git sorts tree entries by name, with a directory's name compared as if it ended in '/'. */
+export declare function sortTreeEntries(entries: TreeEntry[]): TreeEntry[];
+export declare function encodeTree(entries: TreeEntry[]): Uint8Array;
+export declare function decodeTree(payload: Uint8Array): TreeEntry[];
+export type Ident = {
+    name: string;
+    email: string;
+    time: number;
+    tz: string;
+};
+export type Commit = {
+    tree: string;
+    parents: string[];
+    author: Ident;
+    committer: Ident;
+    message: string;
+};
+export declare function encodeCommit(c: Commit): Uint8Array;
+export declare function decodeCommit(payload: Uint8Array): Commit;
+export type Tag = {
+    object: string;
+    type: GitObjectType;
+    tag: string;
+    tagger?: Ident;
+    message: string;
+};
+export declare function encodeTag(t: Tag): Uint8Array;
+export declare function decodeTag(payload: Uint8Array): Tag;