@adecore/merge 0.0.1 → 0.17.0-beta.2

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 - present Bas Milius
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @adecore/merge
+
+Pure line diffs, three-way merge blocks and conflict resolution. It uses no filesystem, Git process, editor or browser API.
+
+```sh
+bun add @adecore/merge
+```
+
+Licensed under FSL-1.1-MIT, see [LICENSE](./LICENSE).
+
+```ts
+import { draftOf, joinLines, shapeOf, splitBlocks, splitLines } from '@adecore/merge';
+
+const base = 'first\r\nold\r\n';
+const ours = 'first\r\nours\r\n';
+const theirs = 'first\r\ntheirs\r\n';
+const blocks = splitBlocks(splitLines(base), splitLines(ours), splitLines(theirs));
+const answers = new Map<number, readonly string[]>();
+for (const [index, block] of blocks.entries()) {
+    if (block.kind === 'conflict') {
+        answers.set(index, ['combined']);
+    }
+}
+const text = joinLines(draftOf(blocks, answers).lines, shapeOf(ours));
+```
+
+The fixed answer above represents a caller's completed decision. Unanswered draft conflicts use ours without markers; saving requires a separate unresolved check. Preserve text shape and verify input versions before writing. The host owns authorization, file access and stale-answer rejection.
+
+Read the [overview](https://adecore.dev/merge/), [lines and diffs](https://adecore.dev/merge/lines) and [three-way merge](https://adecore.dev/merge/three-way).
+
+From the repository root, run `bun run --cwd packages/merge test`, `typecheck` or `build`. The isolated `test:memory` command checks bounded diff memory workloads. A source-relative example is in [examples/resolve-conflict.ts](./examples/resolve-conflict.ts).

package/dist/blocks.d.ts

@@ -0,0 +1,9 @@
+export type MergeBlockKind = 'stable' | 'ours' | 'theirs' | 'both' | 'conflict';
+export interface MergeBlock {
+    kind: MergeBlockKind;
+    base: string[];
+    ours: string[];
+    theirs: string[];
+}
+export declare function splitBlocks(base: readonly string[], ours: readonly string[], theirs: readonly string[]): MergeBlock[];
+export declare function openBlocks(blocks: readonly MergeBlock[]): number;

package/dist/blocks.js

@@ -0,0 +1,82 @@
+import { diffLines } from './diff.js';
+function same(left, right) {
+    return left.length === right.length && left.every((line, index) => line === right[index]);
+}
+function kindOf(base, ours, theirs) {
+    if (same(ours, theirs)) {
+        return same(base, ours) ? 'stable' : 'both';
+    }
+    if (same(base, ours)) {
+        return 'theirs';
+    }
+    if (same(base, theirs)) {
+        return 'ours';
+    }
+    return 'conflict';
+}
+/* How many lines a change adds over what it replaces, which is how far it moves everything after it. */
+function delta(change) {
+    return change.otherEnd - change.otherStart - (change.baseEnd - change.baseStart);
+}
+/*
+ * The three versions of a file as the stretches they agree and disagree on, in reading order. A
+ * stretch is taken up by both sides at once only where their changes overlap in the base, or where
+ * both added something in exactly the same place; anything else is one side's alone and merges
+ * without asking. This is what every other function here counts, draws and resolves.
+ */
+export function splitBlocks(base, ours, theirs) {
+    const ourChanges = diffLines(base, ours);
+    const theirChanges = diffLines(base, theirs);
+    const blocks = [];
+    let baseAt = 0;
+    let ourAt = 0;
+    let theirAt = 0;
+    let ourNext = 0;
+    let theirNext = 0;
+    const push = (baseEnd, ourEnd, theirEnd) => {
+        const stretch = { base: base.slice(baseAt, baseEnd), ours: ours.slice(ourAt, ourEnd), theirs: theirs.slice(theirAt, theirEnd) };
+        if (stretch.base.length > 0 || stretch.ours.length > 0 || stretch.theirs.length > 0) {
+            blocks.push({ kind: kindOf(stretch.base, stretch.ours, stretch.theirs), ...stretch });
+        }
+        baseAt = baseEnd;
+        ourAt = ourEnd;
+        theirAt = theirEnd;
+    };
+    while (ourNext < ourChanges.length || theirNext < theirChanges.length) {
+        const start = Math.min(ourChanges[ourNext]?.baseStart ?? Infinity, theirChanges[theirNext]?.baseStart ?? Infinity);
+        if (start > baseAt) {
+            const length = start - baseAt;
+            push(start, ourAt + length, theirAt + length);
+        }
+        let end = baseAt;
+        let ourGrowth = 0;
+        let theirGrowth = 0;
+        /* The stretch grows while a change of either side reaches into it: two changes that overlap
+           in the base are one thing a person has to look at, however far apart they started. */
+        for (let taken = true; taken;) {
+            taken = false;
+            const reaches = (change) => change !== undefined && change.baseStart <= end && (change.baseStart < end || end === baseAt);
+            while (reaches(ourChanges[ourNext])) {
+                const change = ourChanges[ourNext];
+                end = Math.max(end, change.baseEnd);
+                ourGrowth += delta(change);
+                ourNext += 1;
+                taken = true;
+            }
+            while (reaches(theirChanges[theirNext])) {
+                const change = theirChanges[theirNext];
+                end = Math.max(end, change.baseEnd);
+                theirGrowth += delta(change);
+                theirNext += 1;
+                taken = true;
+            }
+        }
+        push(end, ourAt + (end - baseAt) + ourGrowth, theirAt + (end - baseAt) + theirGrowth);
+    }
+    push(base.length, ours.length, theirs.length);
+    return blocks;
+}
+/* The stretches a person still has to decide on. */
+export function openBlocks(blocks) {
+    return blocks.filter((block) => block.kind === 'conflict').length;
+}

package/dist/diff.d.ts

@@ -0,0 +1,7 @@
+export interface Change {
+    baseStart: number;
+    baseEnd: number;
+    otherStart: number;
+    otherEnd: number;
+}
+export declare function diffLines(base: readonly string[], other: readonly string[]): Change[];

package/dist/diff.js

@@ -0,0 +1,129 @@
+/*
+ * How far apart two files may be before the exact walk costs more than the answer is worth. Past
+ * this the two are answered as one stretch that differs whole, which reads as a single conflict
+ * instead of a list nobody would work through anyway.
+ */
+const MAX_DISTANCE = 4000;
+/* The walk keeps every STRIDE-th state and walks the rounds between two again on the way back: a
+   state per round came to over a hundred megabytes at MAX_DISTANCE. */
+const STRIDE = 64;
+/* One round of the walk: every diagonal of this distance taken as far as its lines match. True once the far corner is reached. */
+function extend(left, right, reach, offset, distance) {
+    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+        const down = diagonal === -distance || (diagonal !== distance && reach[offset + diagonal - 1] < reach[offset + diagonal + 1]);
+        let x = down ? reach[offset + diagonal + 1] : reach[offset + diagonal - 1] + 1;
+        let y = x - diagonal;
+        while (x < left.length && y < right.length && left[x] === right[y]) {
+            x += 1;
+            y += 1;
+        }
+        reach[offset + diagonal] = x;
+        if (x >= left.length && y >= right.length) {
+            return true;
+        }
+    }
+    return false;
+}
+/* The path back from the far corner, one edit per step, in the order the file reads. */
+function backtrack(left, right, saved, distance, offset) {
+    const moves = [];
+    let x = left.length;
+    let y = right.length;
+    const states = Array.from({ length: Math.min(distance, STRIDE) + 1 }, () => new Int32Array(2 * offset + 1));
+    for (let step = distance; step > 0;) {
+        // The states the rounds from the saved one below this step started in, walked again.
+        const first = Math.floor((step - 1) / STRIDE) * STRIDE;
+        states[0].set(saved[first / STRIDE]);
+        for (let round = first; round < step; round += 1) {
+            const next = states[round - first + 1];
+            next.set(states[round - first]);
+            extend(left, right, next, offset, round);
+        }
+        for (; step > first; step -= 1) {
+            const state = states[step - first];
+            const diagonal = x - y;
+            const down = diagonal === -step || (diagonal !== step && state[offset + diagonal - 1] < state[offset + diagonal + 1]);
+            const previous = down ? diagonal + 1 : diagonal - 1;
+            const prevX = state[offset + previous];
+            const prevY = prevX - previous;
+            moves.push({ prevX, prevY, x, y });
+            x = prevX;
+            y = prevY;
+        }
+    }
+    return moves.reverse();
+}
+/*
+ * Myers' greedy walk: for every edit distance it keeps the furthest reach on each diagonal, and every
+ * STRIDE-th state a round started in, which is what the path is read back from once the far corner
+ * is reached. Null once the distance passes what is worth walking.
+ */
+function walk(left, right) {
+    const limit = Math.min(left.length + right.length, MAX_DISTANCE);
+    const offset = limit;
+    const reach = new Int32Array(2 * limit + 1);
+    const saved = [];
+    for (let distance = 0; distance <= limit; distance += 1) {
+        if (distance % STRIDE === 0) {
+            saved.push(reach.slice());
+        }
+        if (extend(left, right, reach, offset, distance)) {
+            return backtrack(left, right, saved, distance, offset);
+        }
+    }
+    return null;
+}
+/* The stretches the moves cover, with edits that follow each other straight away folded into one. */
+function changesOf(moves) {
+    const changes = [];
+    let current = null;
+    for (const move of moves) {
+        // A delete moves along the base side and so raises the diagonal; an insert lowers it.
+        const deleted = move.x - move.y > move.prevX - move.prevY;
+        const editX = deleted ? move.prevX + 1 : move.prevX;
+        const editY = deleted ? move.prevY : move.prevY + 1;
+        if (current !== null && current.baseEnd === move.prevX && current.otherEnd === move.prevY) {
+            current.baseEnd = editX;
+            current.otherEnd = editY;
+        }
+        else {
+            if (current !== null) {
+                changes.push(current);
+            }
+            current = { baseStart: move.prevX, baseEnd: editX, otherStart: move.prevY, otherEnd: editY };
+        }
+        // What follows the edit is a run of equal lines, which ends the stretch.
+        if (move.x !== editX || move.y !== editY) {
+            changes.push(current);
+            current = null;
+        }
+    }
+    if (current !== null) {
+        changes.push(current);
+    }
+    return changes;
+}
+/* Where `other` differs from `base`, in line stretches, in the order they appear. */
+export function diffLines(base, other) {
+    let prefix = 0;
+    while (prefix < base.length && prefix < other.length && base[prefix] === other[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < base.length - prefix && suffix < other.length - prefix && base[base.length - 1 - suffix] === other[other.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const left = base.slice(prefix, base.length - suffix);
+    const right = other.slice(prefix, other.length - suffix);
+    if (left.length === 0 && right.length === 0) {
+        return [];
+    }
+    const moves = left.length === 0 || right.length === 0 ? null : walk(left, right);
+    const changes = moves === null ? [{ baseStart: 0, baseEnd: left.length, otherStart: 0, otherEnd: right.length }] : changesOf(moves);
+    return changes.map((change) => ({
+        baseStart: change.baseStart + prefix,
+        baseEnd: change.baseEnd + prefix,
+        otherStart: change.otherStart + prefix,
+        otherEnd: change.otherEnd + prefix
+    }));
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { diffLines, type Change } from './diff.ts';
+export { openBlocks, splitBlocks, type MergeBlock, type MergeBlockKind } from './blocks.ts';
+export { autoLines, bothLines, draftOf, fingerprint, sideLines, wandLines, type MergeDraft, type MergeSide, type MergeSpan } from './resolve.ts';
+export { joinLines, shapeOf, splitLines, type TextShape } from './text.ts';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { diffLines } from './diff.js';
+export { openBlocks, splitBlocks } from './blocks.js';
+export { autoLines, bothLines, draftOf, fingerprint, sideLines, wandLines } from './resolve.js';
+export { joinLines, shapeOf, splitLines } from './text.js';

package/dist/resolve.d.ts

@@ -0,0 +1,18 @@
+import type { MergeBlock } from './blocks.ts';
+export type MergeSide = 'ours' | 'theirs';
+export declare function sideLines(block: MergeBlock, side: MergeSide): string[];
+export declare function bothLines(block: MergeBlock, first: MergeSide): string[];
+export declare function autoLines(block: MergeBlock): string[] | null;
+export declare function wandLines(block: MergeBlock): string[] | null;
+export declare function fingerprint(block: MergeBlock): string;
+export interface MergeSpan {
+    block: number;
+    kind: MergeBlock['kind'];
+    from: number;
+    to: number;
+}
+export interface MergeDraft {
+    lines: string[];
+    spans: MergeSpan[];
+}
+export declare function draftOf(blocks: readonly MergeBlock[], answered?: ReadonlyMap<number, readonly string[]>): MergeDraft;

package/dist/resolve.js

@@ -0,0 +1,105 @@
+export function sideLines(block, side) {
+    return side === 'ours' ? [...block.ours] : [...block.theirs];
+}
+/* Both sides, one after the other, for the conflict where the two additions both belong. */
+export function bothLines(block, first) {
+    return first === 'ours' ? [...block.ours, ...block.theirs] : [...block.theirs, ...block.ours];
+}
+/* What a block is worth without anyone choosing: the side that changed, or the change both made. */
+export function autoLines(block) {
+    switch (block.kind) {
+        case 'stable':
+        case 'ours':
+        case 'both':
+            return [...block.ours];
+        case 'theirs':
+            return [...block.theirs];
+        case 'conflict':
+            return null;
+    }
+}
+function squashed(lines) {
+    return lines
+        .map((line) => {
+        const body = line.trim();
+        // Indentation is meaning in Python, YAML or a Makefile, so only a blank line loses its own.
+        const indent = body === '' ? '' : line.slice(0, line.length - line.trimStart().length);
+        return `${indent}${body.replace(/\s+/g, ' ')}`;
+    })
+        .join('\n');
+}
+/* Where `inner` starts in `outer` as one run of lines, or -1. */
+function runIn(outer, inner) {
+    for (let start = 0; start + inner.length <= outer.length; start += 1) {
+        if (inner.every((line, index) => outer[start + index] === line)) {
+            return start;
+        }
+    }
+    return -1;
+}
+/*
+ * Whether `outer` holds every line of `inner` and adds nothing `inner` took out: a base line among
+ * what `outer` adds is one `inner` deleted, and taking `outer` would put it back.
+ */
+function covers(base, outer, inner) {
+    const start = runIn(outer, inner);
+    if (inner.length === 0 || start < 0) {
+        return false;
+    }
+    const added = [...outer.slice(0, start), ...outer.slice(start + inner.length)];
+    return added.every((line) => !base.includes(line) || inner.includes(line));
+}
+/*
+ * What the wand makes of a conflict, or null for one that needs a person after all. It closes the
+ * two nobody would think twice about: the sides that differ only in whitespace inside or after a
+ * line, and the side that already holds every line of the other without putting back what the other
+ * deleted. Anything else is a choice, and a wand that guesses at those is a wand nobody trusts twice.
+ */
+export function wandLines(block) {
+    if (block.kind !== 'conflict') {
+        return autoLines(block);
+    }
+    if (squashed(block.ours) === squashed(block.theirs)) {
+        return [...block.ours];
+    }
+    if (covers(block.base, block.ours, block.theirs)) {
+        return [...block.ours];
+    }
+    if (covers(block.base, block.theirs, block.ours)) {
+        return [...block.theirs];
+    }
+    return null;
+}
+/*
+ * A short name for the two sides of one block, so an answer written for it can be checked against
+ * the block it lands on. Not a secret and not a digest anyone leans on: it only has to differ when
+ * the stretch does, and it has to read the same on a daemon and in a browser, which rules out the
+ * one hash a browser cannot take synchronously.
+ */
+export function fingerprint(block) {
+    let hash = 0x811c9dc5;
+    for (const line of [...block.ours, '\u0000', ...block.theirs]) {
+        for (let index = 0; index < line.length; index += 1) {
+            hash = Math.imul(hash ^ line.charCodeAt(index), 0x01000193);
+        }
+        hash = Math.imul(hash ^ 0x0a, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+/*
+ * The merged file to start from: everything that merges by itself is merged, and every conflict
+ * holds our side until someone says otherwise. Never a conflict marker: what a person edits here is
+ * a file that would compile, and the other side is a column away rather than a line below. Blocks
+ * that have already been answered are passed in, which is how a proposal lands in a file nobody has
+ * open.
+ */
+export function draftOf(blocks, answered = new Map()) {
+    const lines = [];
+    const spans = [];
+    for (const [index, block] of blocks.entries()) {
+        const from = lines.length;
+        lines.push(...(answered.get(index) ?? autoLines(block) ?? block.ours));
+        spans.push({ block: index, kind: block.kind, from, to: lines.length });
+    }
+    return { lines, spans };
+}

package/dist/text.d.ts

@@ -0,0 +1,7 @@
+export interface TextShape {
+    eol: '\n' | '\r\n';
+    finalNewline: boolean;
+}
+export declare function shapeOf(text: string): TextShape;
+export declare function splitLines(text: string): string[];
+export declare function joinLines(lines: readonly string[], shape: TextShape): string;

package/dist/text.js

@@ -0,0 +1,22 @@
+/* The line ending a file uses, by the first one in it, and whether it ends on one. */
+export function shapeOf(text) {
+    const line = text.indexOf('\n');
+    return {
+        eol: line > 0 && text[line - 1] === '\r' ? '\r\n' : '\n',
+        finalNewline: text === '' || text.endsWith('\n')
+    };
+}
+/* The lines of a file, without the empty one a trailing newline would leave behind. */
+export function splitLines(text) {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split(/\r\n|\n/);
+    if (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+export function joinLines(lines, shape) {
+    return lines.length === 0 ? '' : lines.join(shape.eol) + (shape.finalNewline ? shape.eol : '');
+}

package/package.json

@@ -1,11 +1,42 @@
 {
   "name": "@adecore/merge",
-  "version": "0.0.1",
-  "description": "Placeholder for the first release.",
+  "version": "0.17.0-beta.2",
+  "description": "Pure line diffs, three-way merge blocks and conflict resolution.",
   "license": "FSL-1.1-MIT",
+  "author": "Bas Milius",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/basmilius/adecore.git",
     "directory": "packages/merge"
+  },
+  "bugs": {
+    "url": "https://github.com/basmilius/adecore/issues"
+  },
+  "homepage": "https://adecore.dev/merge/",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/fixtures"
+  ],
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --conditions=source",
+    "test:memory": "bun --config=scripts/memory.bunfig.toml test src/diff-memory.integration.test.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.2",
+    "@types/node": "^24.13.6",
+    "typescript": "^7.0.2"
   }
 }

package/src/blocks.ts

@@ -0,0 +1,104 @@
+import { diffLines, type Change } from './diff.ts';
+
+/*
+ * What happened to one stretch of a file between the version the two sides started from and what
+ * each of them made of it. Only `conflict` needs a person: the rest is one side's change, or the
+ * same change made twice.
+ */
+export type MergeBlockKind = 'stable' | 'ours' | 'theirs' | 'both' | 'conflict';
+
+export interface MergeBlock {
+    kind: MergeBlockKind;
+    base: string[];
+    ours: string[];
+    theirs: string[];
+}
+
+function same(left: readonly string[], right: readonly string[]): boolean {
+    return left.length === right.length && left.every((line, index) => line === right[index]);
+}
+
+function kindOf(base: readonly string[], ours: readonly string[], theirs: readonly string[]): MergeBlockKind {
+    if (same(ours, theirs)) {
+        return same(base, ours) ? 'stable' : 'both';
+    }
+    if (same(base, ours)) {
+        return 'theirs';
+    }
+    if (same(base, theirs)) {
+        return 'ours';
+    }
+    return 'conflict';
+}
+
+/* How many lines a change adds over what it replaces, which is how far it moves everything after it. */
+function delta(change: Change): number {
+    return change.otherEnd - change.otherStart - (change.baseEnd - change.baseStart);
+}
+
+/*
+ * The three versions of a file as the stretches they agree and disagree on, in reading order. A
+ * stretch is taken up by both sides at once only where their changes overlap in the base, or where
+ * both added something in exactly the same place; anything else is one side's alone and merges
+ * without asking. This is what every other function here counts, draws and resolves.
+ */
+export function splitBlocks(base: readonly string[], ours: readonly string[], theirs: readonly string[]): MergeBlock[] {
+    const ourChanges = diffLines(base, ours);
+    const theirChanges = diffLines(base, theirs);
+    const blocks: MergeBlock[] = [];
+    let baseAt = 0;
+    let ourAt = 0;
+    let theirAt = 0;
+    let ourNext = 0;
+    let theirNext = 0;
+
+    const push = (baseEnd: number, ourEnd: number, theirEnd: number): void => {
+        const stretch = { base: base.slice(baseAt, baseEnd), ours: ours.slice(ourAt, ourEnd), theirs: theirs.slice(theirAt, theirEnd) };
+        if (stretch.base.length > 0 || stretch.ours.length > 0 || stretch.theirs.length > 0) {
+            blocks.push({ kind: kindOf(stretch.base, stretch.ours, stretch.theirs), ...stretch });
+        }
+        baseAt = baseEnd;
+        ourAt = ourEnd;
+        theirAt = theirEnd;
+    };
+
+    while (ourNext < ourChanges.length || theirNext < theirChanges.length) {
+        const start = Math.min(ourChanges[ourNext]?.baseStart ?? Infinity, theirChanges[theirNext]?.baseStart ?? Infinity);
+        if (start > baseAt) {
+            const length = start - baseAt;
+            push(start, ourAt + length, theirAt + length);
+        }
+        let end = baseAt;
+        let ourGrowth = 0;
+        let theirGrowth = 0;
+        /* The stretch grows while a change of either side reaches into it: two changes that overlap
+           in the base are one thing a person has to look at, however far apart they started. */
+        for (let taken = true; taken;) {
+            taken = false;
+            const reaches = (change: Change | undefined): boolean =>
+                change !== undefined && change.baseStart <= end && (change.baseStart < end || end === baseAt);
+            while (reaches(ourChanges[ourNext])) {
+                const change = ourChanges[ourNext]!;
+                end = Math.max(end, change.baseEnd);
+                ourGrowth += delta(change);
+                ourNext += 1;
+                taken = true;
+            }
+            while (reaches(theirChanges[theirNext])) {
+                const change = theirChanges[theirNext]!;
+                end = Math.max(end, change.baseEnd);
+                theirGrowth += delta(change);
+                theirNext += 1;
+                taken = true;
+            }
+        }
+        push(end, ourAt + (end - baseAt) + ourGrowth, theirAt + (end - baseAt) + theirGrowth);
+    }
+    push(base.length, ours.length, theirs.length);
+    return blocks;
+}
+
+/* The stretches a person still has to decide on. */
+export function openBlocks(blocks: readonly MergeBlock[]): number {
+    return blocks.filter((block) => block.kind === 'conflict').length;
+}

package/src/diff.ts

@@ -0,0 +1,153 @@
+/*
+ * One stretch where two versions of a file differ: the lines it covers on each side, `end` exclusive.
+ * An insert covers no line on the base side, a delete none on the other.
+ */
+export interface Change {
+    baseStart: number;
+    baseEnd: number;
+    otherStart: number;
+    otherEnd: number;
+}
+
+/*
+ * How far apart two files may be before the exact walk costs more than the answer is worth. Past
+ * this the two are answered as one stretch that differs whole, which reads as a single conflict
+ * instead of a list nobody would work through anyway.
+ */
+const MAX_DISTANCE = 4000;
+
+/* The walk keeps every STRIDE-th state and walks the rounds between two again on the way back: a
+   state per round came to over a hundred megabytes at MAX_DISTANCE. */
+const STRIDE = 64;
+
+/* One edit and the run of equal lines behind it, as the walk found them. */
+interface Move {
+    prevX: number;
+    prevY: number;
+    x: number;
+    y: number;
+}
+
+/* One round of the walk: every diagonal of this distance taken as far as its lines match. True once the far corner is reached. */
+function extend(left: readonly string[], right: readonly string[], reach: Int32Array, offset: number, distance: number): boolean {
+    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+        const down = diagonal === -distance || (diagonal !== distance && reach[offset + diagonal - 1]! < reach[offset + diagonal + 1]!);
+        let x = down ? reach[offset + diagonal + 1]! : reach[offset + diagonal - 1]! + 1;
+        let y = x - diagonal;
+        while (x < left.length && y < right.length && left[x] === right[y]) {
+            x += 1;
+            y += 1;
+        }
+        reach[offset + diagonal] = x;
+        if (x >= left.length && y >= right.length) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/* The path back from the far corner, one edit per step, in the order the file reads. */
+function backtrack(left: readonly string[], right: readonly string[], saved: readonly Int32Array[], distance: number, offset: number): Move[] {
+    const moves: Move[] = [];
+    let x = left.length;
+    let y = right.length;
+    const states = Array.from({ length: Math.min(distance, STRIDE) + 1 }, () => new Int32Array(2 * offset + 1));
+    for (let step = distance; step > 0;) {
+        // The states the rounds from the saved one below this step started in, walked again.
+        const first = Math.floor((step - 1) / STRIDE) * STRIDE;
+        states[0]!.set(saved[first / STRIDE]!);
+        for (let round = first; round < step; round += 1) {
+            const next = states[round - first + 1]!;
+            next.set(states[round - first]!);
+            extend(left, right, next, offset, round);
+        }
+        for (; step > first; step -= 1) {
+            const state = states[step - first]!;
+            const diagonal = x - y;
+            const down = diagonal === -step || (diagonal !== step && state[offset + diagonal - 1]! < state[offset + diagonal + 1]!);
+            const previous = down ? diagonal + 1 : diagonal - 1;
+            const prevX = state[offset + previous]!;
+            const prevY = prevX - previous;
+            moves.push({ prevX, prevY, x, y });
+            x = prevX;
+            y = prevY;
+        }
+    }
+    return moves.reverse();
+}
+
+/*
+ * Myers' greedy walk: for every edit distance it keeps the furthest reach on each diagonal, and every
+ * STRIDE-th state a round started in, which is what the path is read back from once the far corner
+ * is reached. Null once the distance passes what is worth walking.
+ */
+function walk(left: readonly string[], right: readonly string[]): Move[] | null {
+    const limit = Math.min(left.length + right.length, MAX_DISTANCE);
+    const offset = limit;
+    const reach = new Int32Array(2 * limit + 1);
+    const saved: Int32Array[] = [];
+    for (let distance = 0; distance <= limit; distance += 1) {
+        if (distance % STRIDE === 0) {
+            saved.push(reach.slice());
+        }
+        if (extend(left, right, reach, offset, distance)) {
+            return backtrack(left, right, saved, distance, offset);
+        }
+    }
+    return null;
+}
+
+/* The stretches the moves cover, with edits that follow each other straight away folded into one. */
+function changesOf(moves: readonly Move[]): Change[] {
+    const changes: Change[] = [];
+    let current: Change | null = null;
+    for (const move of moves) {
+        // A delete moves along the base side and so raises the diagonal; an insert lowers it.
+        const deleted = move.x - move.y > move.prevX - move.prevY;
+        const editX = deleted ? move.prevX + 1 : move.prevX;
+        const editY = deleted ? move.prevY : move.prevY + 1;
+        if (current !== null && current.baseEnd === move.prevX && current.otherEnd === move.prevY) {
+            current.baseEnd = editX;
+            current.otherEnd = editY;
+        } else {
+            if (current !== null) {
+                changes.push(current);
+            }
+            current = { baseStart: move.prevX, baseEnd: editX, otherStart: move.prevY, otherEnd: editY };
+        }
+        // What follows the edit is a run of equal lines, which ends the stretch.
+        if (move.x !== editX || move.y !== editY) {
+            changes.push(current);
+            current = null;
+        }
+    }
+    if (current !== null) {
+        changes.push(current);
+    }
+    return changes;
+}
+
+/* Where `other` differs from `base`, in line stretches, in the order they appear. */
+export function diffLines(base: readonly string[], other: readonly string[]): Change[] {
+    let prefix = 0;
+    while (prefix < base.length && prefix < other.length && base[prefix] === other[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < base.length - prefix && suffix < other.length - prefix && base[base.length - 1 - suffix] === other[other.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const left = base.slice(prefix, base.length - suffix);
+    const right = other.slice(prefix, other.length - suffix);
+    if (left.length === 0 && right.length === 0) {
+        return [];
+    }
+    const moves = left.length === 0 || right.length === 0 ? null : walk(left, right);
+    const changes = moves === null ? [{ baseStart: 0, baseEnd: left.length, otherStart: 0, otherEnd: right.length }] : changesOf(moves);
+    return changes.map((change) => ({
+        baseStart: change.baseStart + prefix,
+        baseEnd: change.baseEnd + prefix,
+        otherStart: change.otherStart + prefix,
+        otherEnd: change.otherEnd + prefix
+    }));
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { diffLines, type Change } from './diff.ts';
+export { openBlocks, splitBlocks, type MergeBlock, type MergeBlockKind } from './blocks.ts';
+export { autoLines, bothLines, draftOf, fingerprint, sideLines, wandLines, type MergeDraft, type MergeSide, type MergeSpan } from './resolve.ts';
+export { joinLines, shapeOf, splitLines, type TextShape } from './text.ts';

package/src/resolve.ts

@@ -0,0 +1,130 @@
+import type { MergeBlock } from './blocks.ts';
+
+export type MergeSide = 'ours' | 'theirs';
+
+export function sideLines(block: MergeBlock, side: MergeSide): string[] {
+    return side === 'ours' ? [...block.ours] : [...block.theirs];
+}
+
+/* Both sides, one after the other, for the conflict where the two additions both belong. */
+export function bothLines(block: MergeBlock, first: MergeSide): string[] {
+    return first === 'ours' ? [...block.ours, ...block.theirs] : [...block.theirs, ...block.ours];
+}
+
+/* What a block is worth without anyone choosing: the side that changed, or the change both made. */
+export function autoLines(block: MergeBlock): string[] | null {
+    switch (block.kind) {
+        case 'stable':
+        case 'ours':
+        case 'both':
+            return [...block.ours];
+        case 'theirs':
+            return [...block.theirs];
+        case 'conflict':
+            return null;
+    }
+}
+
+function squashed(lines: readonly string[]): string {
+    return lines
+        .map((line) => {
+            const body = line.trim();
+            // Indentation is meaning in Python, YAML or a Makefile, so only a blank line loses its own.
+            const indent = body === '' ? '' : line.slice(0, line.length - line.trimStart().length);
+            return `${indent}${body.replace(/\s+/g, ' ')}`;
+        })
+        .join('\n');
+}
+
+/* Where `inner` starts in `outer` as one run of lines, or -1. */
+function runIn(outer: readonly string[], inner: readonly string[]): number {
+    for (let start = 0; start + inner.length <= outer.length; start += 1) {
+        if (inner.every((line, index) => outer[start + index] === line)) {
+            return start;
+        }
+    }
+    return -1;
+}
+
+/*
+ * Whether `outer` holds every line of `inner` and adds nothing `inner` took out: a base line among
+ * what `outer` adds is one `inner` deleted, and taking `outer` would put it back.
+ */
+function covers(base: readonly string[], outer: readonly string[], inner: readonly string[]): boolean {
+    const start = runIn(outer, inner);
+    if (inner.length === 0 || start < 0) {
+        return false;
+    }
+    const added = [...outer.slice(0, start), ...outer.slice(start + inner.length)];
+    return added.every((line) => !base.includes(line) || inner.includes(line));
+}
+
+/*
+ * What the wand makes of a conflict, or null for one that needs a person after all. It closes the
+ * two nobody would think twice about: the sides that differ only in whitespace inside or after a
+ * line, and the side that already holds every line of the other without putting back what the other
+ * deleted. Anything else is a choice, and a wand that guesses at those is a wand nobody trusts twice.
+ */
+export function wandLines(block: MergeBlock): string[] | null {
+    if (block.kind !== 'conflict') {
+        return autoLines(block);
+    }
+    if (squashed(block.ours) === squashed(block.theirs)) {
+        return [...block.ours];
+    }
+    if (covers(block.base, block.ours, block.theirs)) {
+        return [...block.ours];
+    }
+    if (covers(block.base, block.theirs, block.ours)) {
+        return [...block.theirs];
+    }
+    return null;
+}
+
+/*
+ * A short name for the two sides of one block, so an answer written for it can be checked against
+ * the block it lands on. Not a secret and not a digest anyone leans on: it only has to differ when
+ * the stretch does, and it has to read the same on a daemon and in a browser, which rules out the
+ * one hash a browser cannot take synchronously.
+ */
+export function fingerprint(block: MergeBlock): string {
+    let hash = 0x811c9dc5;
+    for (const line of [...block.ours, '\u0000', ...block.theirs]) {
+        for (let index = 0; index < line.length; index += 1) {
+            hash = Math.imul(hash ^ line.charCodeAt(index), 0x01000193);
+        }
+        hash = Math.imul(hash ^ 0x0a, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+/* Where one block landed in the draft, `to` exclusive, so a block is a range a person can act on. */
+export interface MergeSpan {
+    block: number;
+    kind: MergeBlock['kind'];
+    from: number;
+    to: number;
+}
+
+export interface MergeDraft {
+    lines: string[];
+    spans: MergeSpan[];
+}
+
+/*
+ * The merged file to start from: everything that merges by itself is merged, and every conflict
+ * holds our side until someone says otherwise. Never a conflict marker: what a person edits here is
+ * a file that would compile, and the other side is a column away rather than a line below. Blocks
+ * that have already been answered are passed in, which is how a proposal lands in a file nobody has
+ * open.
+ */
+export function draftOf(blocks: readonly MergeBlock[], answered: ReadonlyMap<number, readonly string[]> = new Map()): MergeDraft {
+    const lines: string[] = [];
+    const spans: MergeSpan[] = [];
+    for (const [index, block] of blocks.entries()) {
+        const from = lines.length;
+        lines.push(...(answered.get(index) ?? autoLines(block) ?? block.ours));
+        spans.push({ block: index, kind: block.kind, from, to: lines.length });
+    }
+    return { lines, spans };
+}

package/src/text.ts

@@ -0,0 +1,33 @@
+/*
+ * The shape of the file every line is put back into: what ends a line here, and whether the last one
+ * is ended at all. A resolution that loses either rewrites the whole file on the next diff.
+ */
+export interface TextShape {
+    eol: '\n' | '\r\n';
+    finalNewline: boolean;
+}
+
+/* The line ending a file uses, by the first one in it, and whether it ends on one. */
+export function shapeOf(text: string): TextShape {
+    const line = text.indexOf('\n');
+    return {
+        eol: line > 0 && text[line - 1] === '\r' ? '\r\n' : '\n',
+        finalNewline: text === '' || text.endsWith('\n')
+    };
+}
+
+/* The lines of a file, without the empty one a trailing newline would leave behind. */
+export function splitLines(text: string): string[] {
+    if (text === '') {
+        return [];
+    }
+    const lines = text.split(/\r\n|\n/);
+    if (lines[lines.length - 1] === '') {
+        lines.pop();
+    }
+    return lines;
+}
+
+export function joinLines(lines: readonly string[], shape: TextShape): string {
+    return lines.length === 0 ? '' : lines.join(shape.eol) + (shape.finalNewline ? shape.eol : '');
+}