@amalgm/live 0.2.81-main.40832913201 → 0.2.81-main.40972490558

package/dist/git/chain.d.ts

@@ -4,7 +4,8 @@
  *
  * Files: an artifact carries only the blobs its parent's state lacks, so a
  * file the receiver does not already hold is found by walking back to the
- * artifact that first carried it.
+ * artifact that first carried it, each artifact read once and only as far
+ * back as a file asked for first travelled.
  *
  * Objects: a pack is thin against its excluded roots, so it installs once
  * everything they reach stands here; otherwise its parent's pack comes first,
@@ -35,9 +36,10 @@ export interface GitChainPacks {
 export interface GitChainOwnerWait {
     readonly kind: 'owner';
 }
-/** The bytes of every wanted blob: the target's files the receiver does not
- * hold. */
-export declare function gitChainBlobs(target: string, artifact: GitArtifactReader, wants: ReadonlySet<string>): Promise<Checked<ReadonlyMap<string, Uint8Array>>>;
+/** Reads blobs from the chain back from the target: each artifact read
+ * once, only as far back as a blob asked for first travelled. Null for a
+ * blob no artifact on the chain carries. */
+export declare function gitChainReader(target: string, artifact: GitArtifactReader): (oid: string) => Promise<Uint8Array | null>;
 /** The packs that bring the target's objects here. */
 export declare function gitChainPacks(target: string, artifact: GitArtifactReader, holds: GitHolds): Promise<Checked<GitChainPacks | GitChainOwnerWait>>;
 //# sourceMappingURL=chain.d.ts.map

package/dist/git/chain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/git/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,CAAC,gBAAgB,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAEnF,wEAAwE;AACxE,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED;mBACmB;AACnB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED;WACW;AACX,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAC7E,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAS/E;AAED,sDAAsD;AACtD,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAC7E,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,GAAG,iBAAiB,CAAC,CAAC,CAUtE"}
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/git/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,CAAC,gBAAgB,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAEnF,wEAAwE;AACxE,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,gEAAgE;IAChE,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC;AAED;mBACmB;AACnB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB;AAED;;4CAE4C;AAC5C,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAWvH;AAED,sDAAsD;AACtD,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,EAC7E,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,GAAG,iBAAiB,CAAC,CAAC,CAUtE"}

package/dist/git/chain.js

@@ -4,7 +4,8 @@
  *
  * Files: an artifact carries only the blobs its parent's state lacks, so a
  * file the receiver does not already hold is found by walking back to the
- * artifact that first carried it.
+ * artifact that first carried it, each artifact read once and only as far
+ * back as a file asked for first travelled.
  *
  * Objects: a pack is thin against its excluded roots, so it installs once
  * everything they reach stands here; otherwise its parent's pack comes first,
@@ -20,20 +21,22 @@
  * then asks its Git which packs it lacks.
  */
 import { fail, pass } from '../contracts/validate.js';
-/** The bytes of every wanted blob: the target's files the receiver does not
- * hold. */
-export async function gitChainBlobs(target, artifact, wants) {
-    const blobs = new Map();
-    for (let next = target; blobs.size < wants.size;) {
-        if (next === null)
-            return fail(`the chain from ${target} carries no bytes for ${wants.size - blobs.size} wanted files`);
-        const read = await artifact(next);
-        for (const [oid, bytes] of read.blobs)
-            if (wants.has(oid))
-                blobs.set(oid, bytes);
-        next = read.parent;
-    }
-    return pass(blobs);
+/** Reads blobs from the chain back from the target: each artifact read
+ * once, only as far back as a blob asked for first travelled. Null for a
+ * blob no artifact on the chain carries. */
+export function gitChainReader(target, artifact) {
+    const found = new Map();
+    let next = target;
+    return async (oid) => {
+        while (!found.has(oid) && next !== null) {
+            const read = await artifact(next);
+            for (const [blob, bytes] of read.blobs)
+                if (!found.has(blob))
+                    found.set(blob, bytes);
+            next = read.parent;
+        }
+        return found.get(oid) ?? null;
+    };
 }
 /** The packs that bring the target's objects here. */
 export async function gitChainPacks(target, artifact, holds) {

package/dist/git/chain.js.map

@@ -1 +1 @@
-{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../src/git/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAgB,MAAM,0BAA0B,CAAC;AAqBpE;WACW;AACX,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,QAA2B,EAC7E,KAA0B;IAC1B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC5C,KAAK,IAAI,IAAI,GAAkB,MAAM,EAAE,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,GAAG,CAAC;QAChE,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC,kBAAkB,MAAM,yBAAyB,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,eAAe,CAAC,CAAC;QACxH,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK;YAAE,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACjF,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;AACrB,CAAC;AAED,sDAAsD;AACtD,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,QAA2B,EAC7E,KAAe;IACf,MAAM,KAAK,GAAiB,EAAE,CAAC;IAC/B,KAAK,IAAI,IAAI,GAAkB,MAAM,EAAE,IAAI,KAAK,IAAI,GAAG,CAAC;QACtD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QACxF,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACrH,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,CAAC,kBAAkB,MAAM,iDAAiD,CAAC,CAAC;AACzF,CAAC"}
+{"version":3,"file":"chain.js","sourceRoot":"","sources":["../../src/git/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAgB,MAAM,0BAA0B,CAAC;AAqBpE;;4CAE4C;AAC5C,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,QAA2B;IACxE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC5C,IAAI,IAAI,GAAkB,MAAM,CAAC;IACjC,OAAO,KAAK,EAAC,GAAG,EAAC,EAAE;QACjB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YACxC,MAAM,IAAI,GAAgB,MAAM,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC/C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,KAAK;gBAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;oBAAE,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACrF,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QACD,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;IAChC,CAAC,CAAC;AACJ,CAAC;AAED,sDAAsD;AACtD,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,MAAc,EAAE,QAA2B,EAC7E,KAAe;IACf,MAAM,KAAK,GAAiB,EAAE,CAAC;IAC/B,KAAK,IAAI,IAAI,GAAkB,MAAM,EAAE,IAAI,KAAK,IAAI,GAAG,CAAC;QACtD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QACxF,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACrH,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,OAAO,IAAI,CAAC,kBAAkB,MAAM,iDAAiD,CAAC,CAAC;AACzF,CAAC"}

package/dist/git/index.d.ts

@@ -4,4 +4,5 @@ export { compareGitText } from './text.js';
 export * from './artifact.js';
 export * from './chain.js';
 export * from './plan.js';
+export * from './merge.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/git/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/git/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/dist/git/index.js

@@ -4,4 +4,5 @@ export { compareGitText } from './text.js';
 export * from './artifact.js';
 export * from './chain.js';
 export * from './plan.js';
+export * from './merge.js';
 //# sourceMappingURL=index.js.map

package/dist/git/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/git/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/git/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}

package/dist/git/merge.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Keep both: two writers on one disk who each commit keep both commits, and
+ * so do two machines that change one repository at once.
+ *
+ * A repository's records stand in one order, each a whole state. A record
+ * that follows the state this machine last recorded or applied replaces it.
+ * One that does not was made beside it: both moved on from the state where
+ * their chains of records meet, the base, and Apply joins the two here
+ * instead of letting the later replace the earlier. The machine whose record
+ * the cloud accepted first joins: on the other, its own later record protects
+ * its ground from the first (src/apply/local-work.ts). The join stands here
+ * as a person's change to theirs, so this machine records it after theirs and
+ * the other machine applies it plainly. Nothing in a join names the machine
+ * making it, so a third machine that joins the same sides makes the same
+ * state.
+ *
+ * - A Git-directory file takes the side that changed it; theirs when both did.
+ * - A ref, loose or packed, is decided by name: the side that moved it, or
+ *   the later of two on one line of history. A branch both moved apart gets
+ *   a merge commit when Git merges them with no file changed differently;
+ *   otherwise theirs stays and ours is kept beside it, as `git fetch` keeps
+ *   what it will not overwrite, at `<name>-<commit>`; so is a ref ours made
+ *   where theirs's need a folder, or the reverse. A remote-tracking ref
+ *   takes theirs, which the next fetch refreshes.
+ * - A reflog both changed keeps both sides' lines, the side its ref ends at
+ *   last; the stash keeps both sides' entries, ours's on top.
+ * - The index follows HEAD: the index of the side whose commit HEAD names,
+ *   or ours carried onto a merge commit as `git read-tree -m` carries it.
+ *
+ * Where the merge has no answer, theirs replaces ours (`gitMergeable`): refs
+ * kept in reftable, a linked worktree, whose branches its main checkout's
+ * state holds, and sides that differ in format, home or borrowed storage.
+ * Everything Git computes is the host's, through `GitMergeGit`; the rest is
+ * decided here, so every host joins alike and the same sides always make the
+ * same state.
+ */
+import type { Sha256Hex } from '../entities/types.js';
+import { type GitState } from './state.js';
+export interface GitMergeSides {
+    /** Where the two chains of records meet. */
+    readonly base: GitState;
+    /** The state this machine last recorded or applied. */
+    readonly ours: GitState;
+    /** The state of the record being applied. */
+    readonly theirs: GitState;
+}
+/** Who writes the merge commits and their reflog lines. */
+export declare const GIT_MERGE_IDENTITY: {
+    readonly name: "Amalgm";
+    readonly email: "amalgm@localhost";
+};
+export interface GitJoin {
+    readonly commit: string;
+    /** Its committer time in seconds, as its reflog line states it. */
+    readonly time: number;
+}
+/** What the merge asks Git, in the repository holding both sides' objects. */
+export interface GitMergeGit {
+    /** Whether `ancestor` is `descendant` or reached from it. */
+    isAncestor(ancestor: string, descendant: string): Promise<boolean>;
+    /** A merge commit of `theirs` and `ours`, in that order, by
+     * GIT_MERGE_IDENTITY at the later of their committer times, when Git
+     * merges them cleanly and no file changed differently on the two sides;
+     * null otherwise.
+     * The same two commits always make the same commit. */
+    join(theirs: string, ours: string, message: string): Promise<GitJoin | null>;
+    /** What an index becomes when HEAD moves from commit `from` to `to`,
+     * keeping what it stages (`git read-tree -m`): its bytes and the meaning
+     * a GitIndex states; null when Git cannot carry it, or it skips files a
+     * sparse checkout leaves out. */
+    carryIndex(index: Uint8Array, from: string, to: string): Promise<{
+        readonly meaning: string;
+        readonly bytes: Uint8Array;
+    } | null>;
+}
+export interface GitMerge {
+    readonly state: GitState;
+    /** The bytes of the files the merge wrote, by blob ID. */
+    readonly made: ReadonlyMap<string, Uint8Array>;
+    /** The merge commits it made. */
+    readonly joins: readonly string[];
+}
+/** Whether the sides can be joined; otherwise theirs replaces ours. */
+export declare function gitMergeable({ base, ours, theirs }: GitMergeSides): boolean;
+/** Where two chains of records meet: the nearest version both reach through
+ * their parents, or null when they never do. The chains step back in turn,
+ * so the walk costs twice the longer way back. */
+export declare function gitMergeBase(ours: string, theirs: string, parentOf: (version: string) => Promise<string | null>): Promise<string | null>;
+/** The sides joined by the file rule alone, refs as files and the index
+ * theirs's: what a receiver's Git acts under while it merges, its
+ * configuration and borrowed storage. */
+export declare function gitMergeFiles(sides: GitMergeSides): GitState;
+/** The sides joined. `bytes` reads any blob a side's files name. */
+export declare function gitMergeStates(sides: GitMergeSides, bytes: (oid: string) => Promise<Uint8Array>, git: GitMergeGit, sha256: Sha256Hex): Promise<GitMerge>;
+//# sourceMappingURL=merge.d.ts.map

package/dist/git/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/git/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAOtD,OAAO,EAA2D,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGpG,MAAM,WAAW,aAAa;IAC5B,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;CAC3B;AAED,2DAA2D;AAC3D,eAAO,MAAM,kBAAkB;;;CAAyD,CAAC;AAEzF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,8EAA8E;AAC9E,MAAM,WAAW,WAAW;IAC1B,6DAA6D;IAC7D,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE;;;;2DAIuD;IACvD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAC7E;;;qCAGiC;IACjC,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACnI;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/C,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,aAAa,GAAG,OAAO,CAM3E;AAED;;kDAEkD;AAClD,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAC7D,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAe/E;AA+CD;;yCAEyC;AACzC,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,QAAQ,CAI5D;AAyCD,oEAAoE;AACpE,wBAAsB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,EACpG,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuLxD"}

package/dist/git/merge.js

@@ -0,0 +1,385 @@
+/**
+ * Keep both: two writers on one disk who each commit keep both commits, and
+ * so do two machines that change one repository at once.
+ *
+ * A repository's records stand in one order, each a whole state. A record
+ * that follows the state this machine last recorded or applied replaces it.
+ * One that does not was made beside it: both moved on from the state where
+ * their chains of records meet, the base, and Apply joins the two here
+ * instead of letting the later replace the earlier. The machine whose record
+ * the cloud accepted first joins: on the other, its own later record protects
+ * its ground from the first (src/apply/local-work.ts). The join stands here
+ * as a person's change to theirs, so this machine records it after theirs and
+ * the other machine applies it plainly. Nothing in a join names the machine
+ * making it, so a third machine that joins the same sides makes the same
+ * state.
+ *
+ * - A Git-directory file takes the side that changed it; theirs when both did.
+ * - A ref, loose or packed, is decided by name: the side that moved it, or
+ *   the later of two on one line of history. A branch both moved apart gets
+ *   a merge commit when Git merges them with no file changed differently;
+ *   otherwise theirs stays and ours is kept beside it, as `git fetch` keeps
+ *   what it will not overwrite, at `<name>-<commit>`; so is a ref ours made
+ *   where theirs's need a folder, or the reverse. A remote-tracking ref
+ *   takes theirs, which the next fetch refreshes.
+ * - A reflog both changed keeps both sides' lines, the side its ref ends at
+ *   last; the stash keeps both sides' entries, ours's on top.
+ * - The index follows HEAD: the index of the side whose commit HEAD names,
+ *   or ours carried onto a merge commit as `git read-tree -m` carries it.
+ *
+ * Where the merge has no answer, theirs replaces ours (`gitMergeable`): refs
+ * kept in reftable, a linked worktree, whose branches its main checkout's
+ * state holds, and sides that differ in format, home or borrowed storage.
+ * Everything Git computes is the host's, through `GitMergeGit`; the rest is
+ * decided here, so every host joins alike and the same sides always make the
+ * same state.
+ */
+import { utf8Decode, utf8Encode } from '../entities/bytes.js';
+import { GIT_ALTERNATES_PATH } from './alternates.js';
+import { gitBlobId } from './artifact.js';
+import { isGitLockPath } from './plan.js';
+import { gitChainReflog, gitDropPackedRefs, gitLooseRef, gitMergeReflog, gitPackedRefs, gitReflogLine, gitReflogTop, } from './refs.js';
+import { gitSharesObjects, isGitOid } from './state.js';
+import { compareGitText } from './text.js';
+/** Who writes the merge commits and their reflog lines. */
+export const GIT_MERGE_IDENTITY = { name: 'Amalgm', email: 'amalgm@localhost' };
+/** Whether the sides can be joined; otherwise theirs replaces ours. */
+export function gitMergeable({ base, ours, theirs }) {
+    const borrowed = (state) => state.files.find(file => file.path === GIT_ALTERNATES_PATH)?.oid ?? null;
+    const reftable = (state) => state.files.some(file => file.path === 'reftable');
+    return base.format === ours.format && ours.format === theirs.format && !gitSharesObjects(ours)
+        && ours.home?.entity === theirs.home?.entity && ours.home?.path === theirs.home?.path
+        && borrowed(ours) === borrowed(theirs) && ![base, ours, theirs].some(reftable);
+}
+/** Where two chains of records meet: the nearest version both reach through
+ * their parents, or null when they never do. The chains step back in turn,
+ * so the walk costs twice the longer way back. */
+export async function gitMergeBase(ours, theirs, parentOf) {
+    if (ours === theirs)
+        return ours;
+    const at = [ours, theirs];
+    const seen = [new Set([ours]), new Set([theirs])];
+    while (at[0] !== null || at[1] !== null) {
+        for (const side of [0, 1]) {
+            const from = at[side];
+            if (from === null || from === undefined)
+                continue;
+            const parent = at[side] = await parentOf(from);
+            if (parent === null)
+                continue;
+            if (seen[1 - side].has(parent))
+                return parent;
+            seen[side].add(parent);
+        }
+    }
+    return null;
+}
+const FOLDER = '040000';
+const byPath = (files) => new Map(files.map(file => [file.path, file]));
+const same = (left, right) => left === undefined ? right === undefined : right !== undefined && left.mode === right.mode && left.oid === right.oid;
+/** The side that changed an entry from the base; theirs when both did. */
+const changedSide = (base, ours, theirs) => same(ours, theirs) || same(theirs, base) ? ours : theirs;
+function fileRule(base, ours, theirs) {
+    const merged = new Map();
+    for (const path of new Set([...base.keys(), ...ours.keys(), ...theirs.keys()])) {
+        const file = changedSide(base.get(path), ours.get(path), theirs.get(path));
+        if (file !== undefined)
+            merged.set(path, file);
+    }
+    return merged;
+}
+const parents = (path) => {
+    const found = [];
+    for (let at = path.indexOf('/'); at > 0; at = path.indexOf('/', at + 1))
+        found.push(path.slice(0, at));
+    return found;
+};
+/** A tree again, sorted: where an entry stands beneath a file, theirs's
+ * whole subtree there replaces both sides', and every parent folder stands. */
+function asTree(merged, theirs) {
+    const clashes = new Set();
+    for (const path of merged.keys()) {
+        const clash = parents(path).find(parent => merged.has(parent) && merged.get(parent).mode !== FOLDER);
+        if (clash !== undefined)
+            clashes.add(clash);
+    }
+    const clashed = (path) => clashes.has(path) || parents(path).some(parent => clashes.has(parent));
+    if (clashes.size > 0) {
+        for (const path of [...merged.keys()])
+            if (clashed(path))
+                merged.delete(path);
+        for (const [path, file] of theirs)
+            if (clashed(path))
+                merged.set(path, file);
+    }
+    for (const path of [...merged.keys()]) {
+        for (const parent of parents(path))
+            if (!merged.has(parent))
+                merged.set(parent, { path: parent, mode: FOLDER, oid: null });
+    }
+    return [...merged.values()].sort((left, right) => compareGitText(left.path, right.path));
+}
+/** The sides joined by the file rule alone, refs as files and the index
+ * theirs's: what a receiver's Git acts under while it merges, its
+ * configuration and borrowed storage. */
+export function gitMergeFiles(sides) {
+    const theirs = byPath(sides.theirs.files);
+    const files = asTree(fileRule(byPath(sides.base.files), byPath(sides.ours.files), theirs), theirs);
+    return { format: sides.theirs.format, home: sides.theirs.home, files, index: sides.theirs.index };
+}
+const SIDES = ['base', 'ours', 'theirs'];
+const isLooseRef = (file) => file.mode !== FOLDER
+    && (file.path === 'HEAD' || file.path.startsWith('refs/') && !isGitLockPath(file.path));
+const isRefFile = (file) => isLooseRef(file) || file.path === 'packed-refs';
+const isReflogPath = (path) => path.startsWith('logs/') && !isGitLockPath(path);
+/** Where ours is kept beside a ref that ends elsewhere, a detached HEAD's
+ * as a branch: the ref and the commit; flattened beneath its namespace when
+ * the ref's own place is taken, then with the whole commit ID. They name
+ * nothing of the machine joining, so every machine that joins the same sides
+ * names it alike. */
+const besideNames = (name, commit) => {
+    const ref = name === 'HEAD' ? 'refs/heads/detached' : name;
+    const space = /^refs\/[^/]+\//.exec(ref)?.[0] ?? 'refs/';
+    const flat = space + ref.slice(space.length).replace(/\//g, '-');
+    return [`${ref}-${commit.slice(0, 7)}`, `${flat}-${commit.slice(0, 7)}`, `${flat}-${commit}`];
+};
+/** Ref names as Git allows them: none stands where another needs a folder. */
+class RefNames {
+    #names = new Set();
+    #folders = new Set();
+    constructor(names) { for (const name of names)
+        this.add(name); }
+    has(name) { return this.#names.has(name); }
+    add(name) { this.#names.add(name); for (const folder of parents(name))
+        this.#folders.add(folder); }
+    /** Whether a new name would stand beneath one, or above others. */
+    clashes(name) { return this.#folders.has(name) || parents(name).some(folder => this.#names.has(folder)); }
+}
+const STASH_LOG = 'logs/refs/stash';
+/** The sides joined. `bytes` reads any blob a side's files name. */
+export async function gitMergeStates(sides, bytes, git, sha256) {
+    const files = {
+        base: byPath(sides.base.files), ours: byPath(sides.ours.files), theirs: byPath(sides.theirs.files),
+    };
+    const entries = (path) => SIDES.map(side => files[side].get(path));
+    const made = new Map();
+    const make = (path, text) => {
+        const content = typeof text === 'string' ? utf8Encode(text) : text;
+        const oid = gitBlobId(content, sha256);
+        made.set(oid, content);
+        return { path, mode: '100644', oid };
+    };
+    const read = async (file) => file?.oid ? utf8Decode(made.get(file.oid) ?? await bytes(file.oid)) : '';
+    const packed = new Map();
+    const packedOf = (side) => {
+        if (!packed.has(side))
+            packed.set(side, read(files[side].get('packed-refs')).then(gitPackedRefs));
+        return packed.get(side);
+    };
+    const values = new Map();
+    const value = (side, name) => {
+        const key = `${side}\0${name}`;
+        if (!values.has(key)) {
+            const loose = files[side].get(name);
+            values.set(key, loose !== undefined && isLooseRef(loose) ? read(loose).then(gitLooseRef)
+                : name === 'HEAD' ? Promise.resolve(null) : packedOf(side).then(refs => refs.get(name) ?? null));
+        }
+        return values.get(key);
+    };
+    const merged = fileRule(files.base, files.ours, files.theirs);
+    const paths = new Set(SIDES.flatMap(side => [...files[side].keys()]));
+    // A reflog both sides changed keeps both sides' lines, the side its ref
+    // ends at last, so `@{0}` names where it stands; the HEAD's and the
+    // stash's whatever else either did, and one side's dropped ref keeps the
+    // other's moved one. The stash is a stack: ours's entries go on top.
+    const mergeLog = async (path, oursLast) => {
+        const [base, ours, theirs] = entries(path);
+        if (same(ours, theirs) || same(ours, base) || same(theirs, base))
+            return;
+        if ([base, ours, theirs].some(file => file?.mode === FOLDER))
+            return;
+        if (path !== 'logs/HEAD' && path !== STASH_LOG && (ours === undefined || theirs === undefined)) {
+            merged.set(path, (ours ?? theirs));
+            return;
+        }
+        const [was, own, their] = [await read(base), await read(ours), await read(theirs)];
+        const text = oursLast ? gitMergeReflog(was, own, their) : gitMergeReflog(was, their, own);
+        if (text === '')
+            merged.delete(path);
+        else
+            merged.set(path, make(path, path === STASH_LOG ? gitChainReflog(text) : text));
+    };
+    await mergeLog(STASH_LOG, true);
+    // Every ref some side holds differently: the loose files that differ, and
+    // every packed ref when packed-refs does.
+    const names = new Set();
+    for (const path of paths) {
+        const [base, ours, theirs] = entries(path);
+        if (same(base, ours) && same(ours, theirs))
+            continue;
+        if (path === 'packed-refs')
+            for (const side of SIDES)
+                for (const name of (await packedOf(side)).keys())
+                    names.add(name);
+        else if ([base, ours, theirs].some(file => file !== undefined && isLooseRef(file)))
+            names.add(path);
+    }
+    const finals = new Map();
+    const kept = [];
+    const joined = new Map();
+    const keepBeside = (name, commit) => kept.push({ name, commit });
+    for (const name of [...names].sort(compareGitText)) {
+        const [base, ours, theirs] = await Promise.all(SIDES.map(side => value(side, name)));
+        if (ours === theirs || ours === base)
+            continue;
+        if (theirs === base) {
+            finals.set(name, ours);
+            continue;
+        }
+        if (name === 'refs/stash') {
+            finals.set(name, gitReflogTop(await read(merged.get(STASH_LOG))));
+            continue;
+        }
+        if (theirs === null || ours === null) {
+            if (theirs === null)
+                finals.set(name, ours);
+            continue;
+        }
+        if (!isGitOid(sides.theirs.format, ours) || !isGitOid(sides.theirs.format, theirs))
+            continue;
+        if (await git.isAncestor(theirs, ours)) {
+            finals.set(name, ours);
+            continue;
+        }
+        if (await git.isAncestor(ours, theirs) || name.startsWith('refs/remotes/'))
+            continue;
+        const message = `Merge concurrent commits on ${name.slice('refs/heads/'.length)}`;
+        const join = name.startsWith('refs/heads/') ? await git.join(theirs, ours, message) : null;
+        if (join !== null) {
+            finals.set(name, join.commit);
+            joined.set(name, { ...join, theirs, ours, message });
+        }
+        else
+            keepBeside(name, ours);
+    }
+    // A ref ours made where theirs's need a folder, or the reverse, is kept
+    // beside: Git holds no two such names.
+    const theirsNames = [...(await packedOf('theirs')).keys(),
+        ...sides.theirs.files.filter(file => isLooseRef(file) && file.path !== 'HEAD').map(file => file.path)];
+    const standing = new RefNames(theirsNames.filter(name => !finals.has(name) || finals.get(name) !== null));
+    for (const [name, target] of [...finals]) {
+        if (target === null || standing.has(name) || name === 'refs/stash')
+            continue;
+        if (standing.clashes(name)) {
+            finals.delete(name);
+            keepBeside(name, target);
+        }
+    }
+    // The index follows the commit HEAD names. A merge commit's carries ours's
+    // staged work; one Git cannot carry is undone, and ours kept beside.
+    const final = (name) => finals.has(name) ? Promise.resolve(finals.get(name)) : value('theirs', name);
+    const commitOf = async (head, valueOf) => head?.startsWith('ref: ') ? valueOf(head.slice('ref: '.length)) : head;
+    const oursHead = await commitOf(await value('ours', 'HEAD'), name => value('ours', name));
+    const theirsHead = await commitOf(await value('theirs', 'HEAD'), name => value('theirs', name));
+    let headCommit = await commitOf(await final('HEAD'), final);
+    let index;
+    const carried = [...joined].find(([, join]) => join.commit === headCommit);
+    if (carried !== undefined) {
+        const [name, join] = carried;
+        const own = sides.ours.index;
+        const moved = own?.files.length === 1 && oursHead !== null
+            ? await git.carryIndex(await bytes(own.files[0].oid), oursHead, join.commit) : null;
+        if (moved !== null)
+            index = { meaning: moved.meaning, files: [make('index', moved.bytes)] };
+        else {
+            finals.set(name, join.theirs);
+            joined.delete(name);
+            keepBeside(name, join.ours);
+            headCommit = join.theirs;
+        }
+    }
+    if (index === undefined) {
+        const { base, ours, theirs } = { base: sides.base.index, ours: sides.ours.index, theirs: sides.theirs.index };
+        index = headCommit === oursHead && headCommit === theirsHead
+            ? theirs?.meaning === base?.meaning && ours?.meaning !== base?.meaning ? ours : theirs
+            : headCommit === oursHead ? ours : theirs;
+    }
+    // A merge commit's line follows theirs's, its first parent, as `git
+    // merge` writes it.
+    const endsOurs = (end, ours, theirs) => end === ours && end !== theirs;
+    for (const path of paths) {
+        if (!isReflogPath(path) || path === STASH_LOG)
+            continue;
+        const name = path.slice('logs/'.length);
+        await mergeLog(path, name === 'HEAD' ? endsOurs(headCommit, oursHead, theirsHead)
+            : !joined.has(name) && endsOurs(await final(name), await value('ours', name), await value('theirs', name)));
+    }
+    // Theirs's ref files, with each ref that ends elsewhere written loose or
+    // dropped, and ours kept beside.
+    for (const [path, file] of merged)
+        if (isRefFile(file))
+            merged.delete(path);
+    for (const file of sides.theirs.files)
+        if (isRefFile(file))
+            merged.set(file.path, file);
+    const dropped = new Set();
+    for (const [name, target] of finals) {
+        if (target === await value('theirs', name))
+            continue;
+        if (target !== null)
+            merged.set(name, make(name, `${target}\n`));
+        else {
+            if (merged.has(name) && isLooseRef(merged.get(name)))
+                merged.delete(name);
+            dropped.add(name);
+        }
+    }
+    const packedRefs = files.theirs.get('packed-refs');
+    if (dropped.size > 0 && packedRefs !== undefined) {
+        const text = await read(packedRefs), rest = gitDropPackedRefs(text, dropped);
+        if (rest !== text)
+            merged.set('packed-refs', make('packed-refs', rest));
+    }
+    for (const [name, target] of finals)
+        if (target !== null)
+            standing.add(name);
+    const beside = new Map();
+    for (const { name, commit } of kept) {
+        const names = besideNames(name, commit);
+        let side = names.at(-1);
+        for (const candidate of names) {
+            const holds = beside.get(candidate) ?? (standing.has(candidate) ? await final(candidate) : null);
+            if ((holds === null || holds === commit) && !standing.clashes(candidate)) {
+                side = candidate;
+                break;
+            }
+        }
+        standing.add(side);
+        beside.set(side, commit);
+        merged.set(side, make(side, `${commit}\n`));
+        const ours = files.ours.get(`logs/${name}`), theirs = files.theirs.get(`logs/${name}`);
+        if (ours !== undefined)
+            merged.set(`logs/${side}`, { ...ours, path: `logs/${side}` });
+        if (name === 'HEAD')
+            continue;
+        if (theirs !== undefined)
+            merged.set(`logs/${name}`, theirs);
+        else
+            merged.delete(`logs/${name}`);
+    }
+    const head = await final('HEAD');
+    for (const [name, join] of joined) {
+        const line = gitReflogLine(join.theirs, join.commit, GIT_MERGE_IDENTITY, join.time, `commit (merge): ${join.message}`);
+        for (const log of [`logs/${name}`, ...head === `ref: ${name}` ? ['logs/HEAD'] : []]) {
+            const file = merged.get(log);
+            if (file !== undefined && file.mode !== FOLDER)
+                merged.set(log, make(log, await read(file) + line));
+        }
+    }
+    return {
+        state: { format: sides.theirs.format, home: sides.theirs.home, files: asTree(merged, files.theirs), index },
+        made,
+        joins: [...joined.values()].map(join => join.commit),
+    };
+}
+//# sourceMappingURL=merge.js.map