alchemy 2.0.0-beta.77 → 2.0.0-beta.78

package/lib/Git/Protocol/Store.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Abstract storage interfaces the protocol choreography is written against.
+ *
+ * The concrete implementations live in `src/store/` (DO SQLite + R2); the
+ * protocol layer (`UploadPack`, `ReceivePack`, `PackParser`, `PackWriter`,
+ * `Advertise`) depends only on these data-shaped contracts, which keeps the
+ * entire `src/Git/Protocol/` layer unit-testable in plain bun with in-memory fakes.
+ */
+import type * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type * as Stream from "effect/Stream";
+import type { ObjectType, Oid } from "./ObjectCodec.ts";
+declare const StoreError_base: Schema.Class<StoreError, Schema.TaggedStruct<"StoreError", {
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Error produced by any of the abstract store interfaces. Concrete
+ * implementations wrap their own failures (SQL, R2) into this tag so the
+ * protocol layer's error unions stay closed.
+ */
+export declare class StoreError extends StoreError_base {
+}
+/**
+ * Where an object's compressed bytes live (mirrors the `objects.location`
+ * column): `row` = SQLite BLOB, `r2` = oversize loose object in R2,
+ * `pack` = v1.1 compacted pack in R2.
+ */
+export type ObjectLocation = "row" | "r2" | "pack";
+/**
+ * Metadata for one stored object — also the shape of a pack manifest entry
+ * (the fetch closure materializes a list of these, and `PackWriter` streams
+ * from it).
+ */
+export interface ObjectMeta {
+    readonly oid: Oid;
+    readonly type: ObjectType;
+    /** Uncompressed size in bytes. */
+    readonly size: number;
+    /** Stored (zlib-compressed) size in bytes. */
+    readonly zsize: number;
+    /** Storage tier the zdata lives in. */
+    readonly location: ObjectLocation;
+}
+/**
+ * One entry of a fetch-pack manifest. Alias of {@link ObjectMeta} — the
+ * closure walk produces exactly the metadata the pack emitter needs.
+ */
+export type ManifestEntry = ObjectMeta;
+/**
+ * Read access to the object store, as needed by pack parsing (thin-pack base
+ * resolution), pack writing (zdata streaming), negotiation (have existence),
+ * and the push connectivity check.
+ *
+ * All byte payloads are `zlib(content)` **without** the loose header, so pack
+ * emission is `varint(type,size) + zdata` verbatim.
+ */
+export interface ObjectSource {
+    /** Whether an object exists (live objects only, not staged). */
+    readonly has: (oid: Oid) => Effect.Effect<boolean, StoreError>;
+    /**
+     * Filters the given oids down to the subset that exists in the store.
+     * Implementations batch with chunked `IN` lists; order is not guaranteed.
+     */
+    readonly filterExisting: (oids: ReadonlyArray<Oid>) => Effect.Effect<ReadonlyArray<Oid>, StoreError>;
+    /** Object metadata, or `undefined` when the object does not exist. */
+    readonly getMeta: (oid: Oid) => Effect.Effect<ObjectMeta | undefined, StoreError>;
+    /**
+     * Streams the stored compressed bytes (`zlib(content)`, no loose header)
+     * regardless of location (row BLOB, R2 get, v1.1 ranged pack read).
+     */
+    readonly readZData: (oid: Oid) => Stream.Stream<Uint8Array, StoreError>;
+    /**
+     * Reads and inflates the full object content. Used for thin-pack base
+     * resolution and tree/commit walks; callers must respect the per-object
+     * size cap before requesting.
+     */
+    readonly readContent: (oid: Oid) => Effect.Effect<Uint8Array, StoreError>;
+    /**
+     * Emits `varint(type,size) + zdata` for every entry as a stream of LARGE
+     * chunks: objects are read in batches (one statement per ~256) and
+     * concatenated, and pack-resident objects are visited in pack order so
+     * the window cache is sequential. Optional — sources without batching
+     * fall back to one `readZData` per entry (DESIGN §22).
+     */
+    readonly packEntries?: ((entries: ReadonlyArray<ManifestEntry>) => Stream.Stream<Uint8Array, StoreError>) | undefined;
+}
+/**
+ * One advertised ref: full name, tip oid, and — for annotated tags — the
+ * peeled target commit oid (advertised as a `^{}` line).
+ */
+export interface RefRecord {
+    /** Full ref name, e.g. `refs/heads/main`, `refs/tags/v1`. */
+    readonly name: string;
+    readonly oid: Oid;
+    /** Peeled target for annotated tags (`refs/tags/x^{}` advertisement). */
+    readonly peeled?: Oid | undefined;
+}
+/**
+ * A point-in-time snapshot of the ref namespace used to build the v0
+ * advertisement. `HEAD` is virtual: it resolves to
+ * `refs/heads/<defaultBranch>` when that ref exists.
+ */
+export interface RefsSnapshot {
+    /** The repo's default branch short name, e.g. `main`. */
+    readonly defaultBranch: string;
+    /** All refs, sorted by name (the advertisement preserves this order). */
+    readonly refs: ReadonlyArray<RefRecord>;
+}
+/**
+ * Inputs to the fetch closure computation (implemented over the commit graph
+ * in `src/Git/Store/Closure.ts`).
+ */
+export interface ClosureRequest {
+    /** Requested tips (from `want` lines). */
+    readonly wants: ReadonlyArray<Oid>;
+    /**
+     * Common commits negotiated with the client (the ACKed haves). The walk
+     * stops at these boundaries.
+     */
+    readonly haves: ReadonlyArray<Oid>;
+    /** Depth bound from `deepen <n>`, when the client requested a shallow fetch. */
+    readonly depth?: number | undefined;
+    /** The client's existing shallow tips (additional walk boundaries). */
+    readonly clientShallow: ReadonlyArray<Oid>;
+    /**
+     * The REPO's own shallow boundary (commits whose parents were never
+     * ingested — a depth-limited import). These never expand in any walk and
+     * always surface as `shallow <oid>` lines when included in a pack, so
+     * clones of a shallow repo are themselves shallow (and fsck-clean).
+     */
+    readonly repoShallow?: ReadonlyArray<Oid> | undefined;
+}
+/**
+ * The result of a closure computation: the pack manifest plus the shallow
+ * boundary bookkeeping for the response's shallow section.
+ */
+export interface ClosureResult {
+    /**
+     * Every object to pack (commits + trees + blobs + tags), each exactly once.
+     * Materialized before streaming so the pack header count is known upfront.
+     */
+    readonly entries: ReadonlyArray<ManifestEntry>;
+    /** Commits that became shallow boundaries (`shallow <oid>` lines). */
+    readonly shallow: ReadonlyArray<Oid>;
+    /**
+     * Previously-shallow client tips that are now complete
+     * (`unshallow <oid>` lines).
+     */
+    readonly unshallow: ReadonlyArray<Oid>;
+}
+/**
+ * Computes the object closure for a fetch: BFS from wants over the commit
+ * graph stopping at haves (generation-bounded), depth-bounded when shallow,
+ * plus the full tree/blob closure of the frontier commits.
+ */
+export interface ClosureSource {
+    readonly commitClosure: (request: ClosureRequest) => Effect.Effect<ClosureResult, StoreError>;
+}
+export {};
+//# sourceMappingURL=Store.d.ts.map

package/lib/Git/Protocol/Store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../../src/Git/Protocol/Store.ts"],"names":[],"mappings":"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"}

package/lib/Git/Protocol/Store.js

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+/**
+ * Error produced by any of the abstract store interfaces. Concrete
+ * implementations wrap their own failures (SQL, R2) into this tag so the
+ * protocol layer's error unions stay closed.
+ */
+export class StoreError extends Schema.TaggedError()("StoreError", {
+    reason: Schema.String,
+}) {
+}
+//# sourceMappingURL=Store.js.map

package/lib/Git/Protocol/Store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.js","sourceRoot":"","sources":["../../../src/Git/Protocol/Store.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,MAAM,CAAC,WAAW,EAAc,CAAC,YAAY,EAAE;IAC7E,MAAM,EAAE,MAAM,CAAC,MAAM;CACtB,CAAC;CAAG"}

package/lib/Git/Protocol/TreeDiff.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Pure recursive tree diff (the server-side diff surface, DESIGN.md §5).
+ *
+ * Compares two trees keyed by entry **name** (NOT a two-pointer merge —
+ * git's canonical sort treats directories as `name/`, so a name that is a
+ * blob in one tree and a tree in the other would mis-pair). Only descends
+ * into subtree pairs whose oids differ; identical oids (with identical
+ * modes) are skipped without reading the subtree at all. That pruning is
+ * what makes a 12k-file tree cost O(changed) — a commit touching k files
+ * opens only the ~k·depth trees on the changed root-to-leaf paths (each a
+ * single SQLite row read + inflate of a few KB).
+ *
+ * Worst case (root commit: everything added) is bounded by the caps:
+ * recursion **stops descending** once {@link MAX_DIFF_FILES} entries are
+ * emitted (it does not enumerate-then-truncate) and
+ * {@link MAX_DIFF_TREE_READS} bounds tree opens defensively.
+ *
+ * Like the rest of `src/Git/Protocol/`, this module depends only on data-shaped
+ * store contracts so it stays unit-testable with in-memory fakes.
+ */
+import * as Effect from "effect/Effect";
+import { type Oid } from "./ObjectCodec.ts";
+import { StoreError } from "./Store.ts";
+/** Max files emitted by a tree diff before `truncated: true`. */
+export declare const MAX_DIFF_FILES = 1000;
+/**
+ * Defensive bound on tree objects opened per diff (a 12k-file repo with
+ * identical-subtree pruning opens O(changed-paths · depth), typically <50).
+ */
+export declare const MAX_DIFF_TREE_READS = 5000;
+/** One changed file (see the REST `DiffEntry` schema). */
+export interface DiffEntryData {
+    readonly path: string;
+    readonly status: "added" | "removed" | "modified";
+    readonly oldOid?: string | undefined;
+    readonly newOid?: string | undefined;
+    readonly oldMode?: string | undefined;
+    readonly newMode?: string | undefined;
+    readonly oldSize?: number | undefined;
+    readonly newSize?: number | undefined;
+}
+/** Result of {@link diffTrees}. */
+export interface TreeDiffResult {
+    readonly files: Array<DiffEntryData>;
+    readonly truncated: boolean;
+}
+/**
+ * The read surface {@link diffTrees} needs — a structural subset of
+ * `ObjectStore` (`readContent` + `getMetaBatch`).
+ */
+export interface TreeDiffObjects {
+    /** Reads and inflates the full object content. */
+    readonly readContent: (oid: Oid) => Effect.Effect<Uint8Array, StoreError>;
+    /** Batched metadata; missing oids are simply absent from the map. */
+    readonly getMetaBatch: (oids: ReadonlyArray<Oid>) => Effect.Effect<ReadonlyMap<Oid, {
+        readonly size: number;
+    }>, StoreError>;
+}
+/**
+ * Recursive tree diff. `oldTree`/`newTree` are tree oids; `undefined`
+ * means the empty tree on that side (a root commit diffs against
+ * `undefined` and every file comes out `added`).
+ *
+ * Mode-only changes (same blob oid, different mode) still report
+ * `modified`. Kind changes (blob↔tree, gitlink↔tree) emit the removal of
+ * everything on the old side and the addition of everything on the new
+ * side. Gitlink (mode `160000`) entries are leaves whose oids are commit
+ * oids — they carry no sizes.
+ */
+export declare const diffTrees: (objects: TreeDiffObjects, oldTree: Oid | undefined, newTree: Oid | undefined) => Effect.Effect<TreeDiffResult, StoreError>;
+/**
+ * The paths that make a three-way merge non-trivial: changed on **both**
+ * sides relative to the merge base (minus paths where both sides made the
+ * identical change — same new oid+mode, or both deleted), plus
+ * directory/file collisions where a leaf now occupies `p` on one side
+ * while the other side changed something under `p/`. Sorted.
+ */
+export declare const conflictingPaths: (baseChanges: ReadonlyArray<DiffEntryData>, headChanges: ReadonlyArray<DiffEntryData>) => Array<string>;
+/** A tree object created by {@link applyTreeChanges} (bottom-up order). */
+export interface NewTreeObject {
+    readonly oid: Oid;
+    readonly content: Uint8Array;
+}
+/** Result of {@link applyTreeChanges}. */
+export interface ApplyTreeChangesResult {
+    /** Root tree oid after the changes (may equal `baseTree` on a no-op). */
+    readonly root: Oid;
+    /**
+     * Every tree object whose content was (re)built, bottom-up. Some may
+     * already exist in the store — staging is idempotent, so callers just
+     * stage them all.
+     */
+    readonly newTrees: ReadonlyArray<NewTreeObject>;
+}
+/**
+ * Applies leaf-level changes (a {@link diffTrees} file list, e.g. the
+ * mergeBase→head changes of a trivial three-way merge) onto `baseTree`,
+ * rebuilding every touched directory bottom-up with the canonical
+ * {@link encodeTree}. Directories that become empty are dropped from their
+ * parent (git has no empty trees in practice).
+ *
+ * Kind changes compose from the diff's leaf pairs without special cases:
+ * dir→file arrives as deletions under `p/` plus a leaf add at `p` (the
+ * emptied subtree is dropped, then the blob wins); file→dir is the mirror
+ * (the rebuilt subtree replaces the removed blob).
+ *
+ * **No blob is ever created** — every blob/gitlink oid referenced by an
+ * add/modify must already exist in the store (it came in with the head
+ * push). Gitlink oids are commit oids and are exempt from the existence
+ * assertion; any missing *blob* fails with {@link StoreError} (connectivity
+ * invariant).
+ */
+export declare const applyTreeChanges: (objects: TreeDiffObjects, baseTree: Oid, changes: ReadonlyArray<DiffEntryData>) => Effect.Effect<ApplyTreeChangesResult, StoreError>;
+//# sourceMappingURL=TreeDiff.d.ts.map

package/lib/Git/Protocol/TreeDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeDiff.d.ts","sourceRoot":"","sources":["../../../src/Git/Protocol/TreeDiff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAQL,KAAK,GAAG,EAET,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,iEAAiE;AACjE,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,0DAA0D;AAC1D,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IAC1E,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,CACrB,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KACrB,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,UAAU,CAAC,CAAC;CAC7E;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,YACX,eAAe,WACf,GAAG,GAAG,SAAS,WACf,GAAG,GAAG,SAAS,KACvB,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,UAAU,CAoJvC,CAAC;AAUL;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,gBACd,aAAa,CAAC,aAAa,CAAC,eAC5B,aAAa,CAAC,aAAa,CAAC,KACxC,KAAK,CAAC,MAAM,CAiCd,CAAC;AAMF,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;CAC9B;AAED,0CAA0C;AAC1C,MAAM,WAAW,sBAAsB;IACrC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;CACjD;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,YAClB,eAAe,YACd,GAAG,WACJ,aAAa,CAAC,aAAa,CAAC,KACpC,MAAM,CAAC,MAAM,CAAC,sBAAsB,EAAE,UAAU,CAuH/C,CAAC"}

package/lib/Git/Protocol/TreeDiff.js

@@ -0,0 +1,347 @@
+/**
+ * Pure recursive tree diff (the server-side diff surface, DESIGN.md §5).
+ *
+ * Compares two trees keyed by entry **name** (NOT a two-pointer merge —
+ * git's canonical sort treats directories as `name/`, so a name that is a
+ * blob in one tree and a tree in the other would mis-pair). Only descends
+ * into subtree pairs whose oids differ; identical oids (with identical
+ * modes) are skipped without reading the subtree at all. That pruning is
+ * what makes a 12k-file tree cost O(changed) — a commit touching k files
+ * opens only the ~k·depth trees on the changed root-to-leaf paths (each a
+ * single SQLite row read + inflate of a few KB).
+ *
+ * Worst case (root commit: everything added) is bounded by the caps:
+ * recursion **stops descending** once {@link MAX_DIFF_FILES} entries are
+ * emitted (it does not enumerate-then-truncate) and
+ * {@link MAX_DIFF_TREE_READS} bounds tree opens defensively.
+ *
+ * Like the rest of `src/Git/Protocol/`, this module depends only on data-shaped
+ * store contracts so it stays unit-testable with in-memory fakes.
+ */
+import * as Effect from "effect/Effect";
+import { encodeTree, GITLINK_MODE, hashObject, ObjectType, parseTree, TREE_MODE, treeEntryKind, } from "./ObjectCodec.js";
+import { StoreError } from "./Store.js";
+/** Max files emitted by a tree diff before `truncated: true`. */
+export const MAX_DIFF_FILES = 1000;
+/**
+ * Defensive bound on tree objects opened per diff (a 12k-file repo with
+ * identical-subtree pruning opens O(changed-paths · depth), typically <50).
+ */
+export const MAX_DIFF_TREE_READS = 5000;
+/**
+ * Recursive tree diff. `oldTree`/`newTree` are tree oids; `undefined`
+ * means the empty tree on that side (a root commit diffs against
+ * `undefined` and every file comes out `added`).
+ *
+ * Mode-only changes (same blob oid, different mode) still report
+ * `modified`. Kind changes (blob↔tree, gitlink↔tree) emit the removal of
+ * everything on the old side and the addition of everything on the new
+ * side. Gitlink (mode `160000`) entries are leaves whose oids are commit
+ * oids — they carry no sizes.
+ */
+export const diffTrees = (objects, oldTree, newTree) => Effect.gen(function* () {
+    const files = [];
+    let treeReads = 0;
+    let truncated = false;
+    const readTree = Effect.fn(function* (oid) {
+        if (++treeReads > MAX_DIFF_TREE_READS) {
+            truncated = true;
+            return [];
+        }
+        const content = yield* objects.readContent(oid);
+        return yield* parseTree(content).pipe(Effect.mapError((e) => new StoreError({ reason: e.reason })));
+    });
+    const emit = (entry) => {
+        if (files.length >= MAX_DIFF_FILES) {
+            truncated = true;
+            return false;
+        }
+        files.push(entry);
+        return true;
+    };
+    /** Emit every blob/gitlink under `tree` as added or removed. */
+    const emitAll = (tree, prefix, side) => Effect.gen(function* () {
+        if (truncated)
+            return;
+        const entries = yield* readTree(tree);
+        for (const e of entries) {
+            if (truncated)
+                return;
+            const path = prefix + e.name;
+            const kind = treeEntryKind(e.mode);
+            if (kind === "tree") {
+                yield* emitAll(e.oid, `${path}/`, side);
+                continue;
+            }
+            // blob or gitlink — a leaf either way
+            emit(side === "added"
+                ? { path, status: "added", newOid: e.oid, newMode: e.mode }
+                : { path, status: "removed", oldOid: e.oid, oldMode: e.mode });
+        }
+    });
+    const walk = (oldOid, newOid, prefix) => Effect.gen(function* () {
+        if (truncated)
+            return;
+        if (oldOid === newOid)
+            return; // identical-subtree prune (root incl.)
+        if (oldOid === undefined) {
+            if (newOid !== undefined)
+                yield* emitAll(newOid, prefix, "added");
+            return;
+        }
+        if (newOid === undefined) {
+            yield* emitAll(oldOid, prefix, "removed");
+            return;
+        }
+        const oldEntries = yield* readTree(oldOid);
+        const newEntries = yield* readTree(newOid);
+        const oldByName = new Map(oldEntries.map((e) => [e.name, e]));
+        const newByName = new Map(newEntries.map((e) => [e.name, e]));
+        const names = Array.from(new Set([...oldByName.keys(), ...newByName.keys()])).sort(); // deterministic output order
+        for (const name of names) {
+            if (truncated)
+                return;
+            const o = oldByName.get(name);
+            const n = newByName.get(name);
+            const path = prefix + name;
+            if (o === undefined) {
+                // added on the new side
+                const kind = treeEntryKind(n.mode);
+                if (kind === "tree")
+                    yield* emitAll(n.oid, `${path}/`, "added");
+                else {
+                    emit({ path, status: "added", newOid: n.oid, newMode: n.mode });
+                }
+                continue;
+            }
+            if (n === undefined) {
+                const kind = treeEntryKind(o.mode);
+                if (kind === "tree")
+                    yield* emitAll(o.oid, `${path}/`, "removed");
+                else {
+                    emit({ path, status: "removed", oldOid: o.oid, oldMode: o.mode });
+                }
+                continue;
+            }
+            if (o.oid === n.oid && o.mode === n.mode)
+                continue; // untouched — prune
+            const oKind = treeEntryKind(o.mode);
+            const nKind = treeEntryKind(n.mode);
+            if (oKind === "tree" && nKind === "tree") {
+                yield* walk(o.oid, n.oid, `${path}/`); // descend: oids differ
+            }
+            else if (oKind === "tree" || nKind === "tree") {
+                // kind change (blob↔tree, gitlink↔tree): removed + added
+                if (oKind === "tree")
+                    yield* emitAll(o.oid, `${path}/`, "removed");
+                else {
+                    emit({ path, status: "removed", oldOid: o.oid, oldMode: o.mode });
+                }
+                if (nKind === "tree")
+                    yield* emitAll(n.oid, `${path}/`, "added");
+                else {
+                    emit({ path, status: "added", newOid: n.oid, newMode: n.mode });
+                }
+            }
+            else {
+                // blob/gitlink on both sides: content and/or mode change.
+                // Mode-only change (o.oid === n.oid) still reports `modified`.
+                emit({
+                    path,
+                    status: "modified",
+                    oldOid: o.oid,
+                    newOid: n.oid,
+                    oldMode: o.mode,
+                    newMode: n.mode,
+                });
+            }
+        }
+    });
+    yield* walk(oldTree, newTree, "");
+    // Fill sizes for blob entries in ONE chunked metadata query so clients
+    // can gate binary/oversize files without fetching. Gitlink oids won't
+    // be in `objects` and simply stay size-less.
+    const blobOids = new Set();
+    for (const f of files) {
+        if (f.oldOid !== undefined && f.oldMode !== GITLINK_MODE) {
+            blobOids.add(f.oldOid);
+        }
+        if (f.newOid !== undefined && f.newMode !== GITLINK_MODE) {
+            blobOids.add(f.newOid);
+        }
+    }
+    const metas = yield* objects.getMetaBatch(Array.from(blobOids));
+    const sized = files.map((f) => ({
+        ...f,
+        oldSize: f.oldOid !== undefined ? metas.get(f.oldOid)?.size : undefined,
+        newSize: f.newOid !== undefined ? metas.get(f.newOid)?.size : undefined,
+    }));
+    return { files: sized, truncated };
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// conflictingPaths — the trivial-merge admissibility test
+// ─────────────────────────────────────────────────────────────────────────────
+/** `true` when both sides made the identical change (same result). */
+const identicalChange = (a, b) => a.status === b.status && a.newOid === b.newOid && a.newMode === b.newMode;
+/**
+ * The paths that make a three-way merge non-trivial: changed on **both**
+ * sides relative to the merge base (minus paths where both sides made the
+ * identical change — same new oid+mode, or both deleted), plus
+ * directory/file collisions where a leaf now occupies `p` on one side
+ * while the other side changed something under `p/`. Sorted.
+ */
+export const conflictingPaths = (baseChanges, headChanges) => {
+    const conflicts = new Set();
+    const baseBy = new Map(baseChanges.map((f) => [f.path, f]));
+    const headBy = new Map(headChanges.map((f) => [f.path, f]));
+    for (const [path, head] of headBy) {
+        const base = baseBy.get(path);
+        if (base !== undefined && !identicalChange(base, head)) {
+            conflicts.add(path);
+        }
+    }
+    // Directory/file collision: one side's add/modify puts a *leaf* at `dir`
+    // while the other side changes a path under `dir/` — the leaf and the
+    // directory cannot both exist. (A `removed` ancestor never collides: at
+    // the merge base a name is either a leaf or a directory, never both.)
+    const addAncestorConflicts = (leaves, others) => {
+        for (const path of others.keys()) {
+            let idx = path.lastIndexOf("/");
+            while (idx > 0) {
+                const dir = path.slice(0, idx);
+                const leaf = leaves.get(dir);
+                if (leaf !== undefined && leaf.newOid !== undefined) {
+                    conflicts.add(path);
+                }
+                idx = dir.lastIndexOf("/");
+            }
+        }
+    };
+    addAncestorConflicts(baseBy, headBy);
+    addAncestorConflicts(headBy, baseBy);
+    return Array.from(conflicts).sort();
+};
+/**
+ * Applies leaf-level changes (a {@link diffTrees} file list, e.g. the
+ * mergeBase→head changes of a trivial three-way merge) onto `baseTree`,
+ * rebuilding every touched directory bottom-up with the canonical
+ * {@link encodeTree}. Directories that become empty are dropped from their
+ * parent (git has no empty trees in practice).
+ *
+ * Kind changes compose from the diff's leaf pairs without special cases:
+ * dir→file arrives as deletions under `p/` plus a leaf add at `p` (the
+ * emptied subtree is dropped, then the blob wins); file→dir is the mirror
+ * (the rebuilt subtree replaces the removed blob).
+ *
+ * **No blob is ever created** — every blob/gitlink oid referenced by an
+ * add/modify must already exist in the store (it came in with the head
+ * push). Gitlink oids are commit oids and are exempt from the existence
+ * assertion; any missing *blob* fails with {@link StoreError} (connectivity
+ * invariant).
+ */
+export const applyTreeChanges = (objects, baseTree, changes) => Effect.gen(function* () {
+    // Connectivity invariant: referenced blobs must already exist.
+    const requiredBlobs = new Set();
+    for (const change of changes) {
+        if (change.newOid !== undefined &&
+            change.newMode !== undefined &&
+            treeEntryKind(change.newMode) !== "commit") {
+            requiredBlobs.add(change.newOid);
+        }
+    }
+    if (requiredBlobs.size > 0) {
+        const metas = yield* objects.getMetaBatch(Array.from(requiredBlobs));
+        for (const oid of requiredBlobs) {
+            if (!metas.has(oid)) {
+                return yield* new StoreError({
+                    reason: `applyTreeChanges: referenced blob ${oid} is missing from the store`,
+                });
+            }
+        }
+    }
+    // Build the nested change tree keyed by path segment.
+    const rootNode = { children: new Map() };
+    for (const change of changes) {
+        const segments = change.path.split("/");
+        let node = rootNode;
+        for (let i = 0; i < segments.length; i++) {
+            node.children ??= new Map();
+            const name = segments[i];
+            let next = node.children.get(name);
+            if (next === undefined) {
+                next = {};
+                node.children.set(name, next);
+            }
+            node = next;
+        }
+        node.leaf = change;
+    }
+    const newTrees = [];
+    const readEntries = Effect.fn(function* (oid) {
+        const content = yield* objects.readContent(oid);
+        return yield* parseTree(content).pipe(Effect.mapError((e) => new StoreError({ reason: e.reason })));
+    });
+    /**
+     * Rebuilds one directory: `baseOid` is the base-side subtree (absent
+     * when the directory is new), `node.children` the changes below it.
+     * Returns the resulting tree oid, or `undefined` when it came out
+     * empty.
+     */
+    const build = (baseOid, children) => Effect.gen(function* () {
+        const baseEntries = baseOid === undefined ? [] : yield* readEntries(baseOid);
+        const byName = new Map(baseEntries.map((e) => [e.name, e]));
+        for (const [name, node] of children) {
+            const base = byName.get(name);
+            // 1. children first: rebuild the subtree below this name.
+            let subtree;
+            if (node.children !== undefined) {
+                const subtreeBase = base !== undefined && treeEntryKind(base.mode) === "tree"
+                    ? base.oid
+                    : undefined;
+                subtree = yield* build(subtreeBase, node.children);
+            }
+            // 2. the leaf op at this exact name decides the entry.
+            if (node.leaf !== undefined &&
+                node.leaf.newOid !== undefined &&
+                node.leaf.newMode !== undefined) {
+                // added/modified blob or gitlink — the leaf wins.
+                byName.set(name, {
+                    mode: node.leaf.newMode,
+                    name,
+                    oid: node.leaf.newOid,
+                });
+            }
+            else if (node.children !== undefined) {
+                // subtree result (also covers file→dir: the removed blob is
+                // replaced by the rebuilt subtree, or dropped when empty).
+                if (subtree === undefined)
+                    byName.delete(name);
+                else
+                    byName.set(name, { mode: TREE_MODE, name, oid: subtree });
+            }
+            else if (node.leaf !== undefined) {
+                // removed leaf
+                byName.delete(name);
+            }
+        }
+        const entries = Array.from(byName.values());
+        if (entries.length === 0)
+            return undefined;
+        const content = yield* encodeTree(entries).pipe(Effect.mapError((e) => new StoreError({ reason: e.reason })));
+        const oid = yield* hashObject(ObjectType.tree, content);
+        if (oid !== baseOid) {
+            newTrees.push({ oid, content });
+        }
+        return oid;
+    });
+    const root = yield* build(baseTree, rootNode.children ?? new Map());
+    if (root === undefined) {
+        // Everything was deleted: the canonical empty tree.
+        const content = new Uint8Array(0);
+        const oid = yield* hashObject(ObjectType.tree, content);
+        newTrees.push({ oid, content });
+        return { root: oid, newTrees };
+    }
+    return { root, newTrees };
+});
+//# sourceMappingURL=TreeDiff.js.map