cursedbelt-core 2.14.0 → 2.14.1

package/dist/core/upload-precheck/plan.d.ts

@@ -14,7 +14,11 @@
  *    hashes AS they finish: one request in flight, each carrying every hash completed since the
  *    last. Uploads of the first new files begin while later ones are still being hashed.
  * 4. **A repeat inside the drop** (the same bytes under two names) is caught by its hash without
- *    asking anybody, and only the first is sent.
+ *    asking anybody, and only the first IN THE DROP is sent — never whichever hash happened to
+ *    finish first. Hashes finish out of order (a busy disk, `crypto.subtle` on its own threads), so
+ *    a file's hash is held until every earlier file of its SIZE has one: only those can be its
+ *    repeat, and they started hashing before it did. music's gate went red on exactly that race
+ *    (forge task 4407): "song again.wav" sent and "song.wav" called the copy.
  *
  * A pre-check that FAILS never blocks an upload: the sizes question failing sends everything as
  * it would have before the pre-check existed (each app's own after-the-fact check still stands),

package/dist/core/upload-precheck/plan.js

@@ -14,7 +14,11 @@
  *    hashes AS they finish: one request in flight, each carrying every hash completed since the
  *    last. Uploads of the first new files begin while later ones are still being hashed.
  * 4. **A repeat inside the drop** (the same bytes under two names) is caught by its hash without
- *    asking anybody, and only the first is sent.
+ *    asking anybody, and only the first IN THE DROP is sent — never whichever hash happened to
+ *    finish first. Hashes finish out of order (a busy disk, `crypto.subtle` on its own threads), so
+ *    a file's hash is held until every earlier file of its SIZE has one: only those can be its
+ *    repeat, and they started hashing before it did. music's gate went red on exactly that race
+ *    (forge task 4407): "song again.wav" sent and "song.wav" called the copy.
  *
  * A pre-check that FAILS never blocks an upload: the sizes question failing sends everything as
  * it would have before the pre-check existed (each app's own after-the-fact check still stands),
@@ -168,12 +172,40 @@ export async function planUploads(options) {
         else
             linger ??= setTimeout(kick, lingerMs);
     };
+    // Step 4's drop order: each size shared inside the drop is a line, in drop order, and a hash
+    // (or a failure to read, `null`) is settled only once everything ahead of it in its line has one.
+    const lines = new Map();
+    for (const item of candidates) {
+        const size = sizeOf(item);
+        if ((inDrop.get(size) ?? 0) > 1)
+            lines.set(size, [...(lines.get(size) ?? []), item]);
+    }
+    const arrived = new Map();
+    const apply = (item, sha256) => {
+        if (sha256 !== null)
+            settle(item, sha256);
+        else
+            decide({ kind: "upload", item });
+    };
+    const arrive = (item, sha256) => {
+        const line = lines.get(sizeOf(item));
+        if (!line) {
+            apply(item, sha256);
+            return;
+        }
+        arrived.set(item, sha256);
+        while (line.length > 0 && arrived.has(line[0])) {
+            const head = line.shift();
+            apply(head, arrived.get(head) ?? null);
+            arrived.delete(head);
+        }
+    };
     const toHash = [];
     for (const item of candidates) {
         const known = keyOf ? remembered.get(keyOf(item)) : undefined;
         if (known) {
             result.stats.memoHits++;
-            settle(item, known);
+            arrive(item, known);
         }
         else
             toHash.push(item);
@@ -206,7 +238,7 @@ export async function planUploads(options) {
                     result.stats.hashedBytes += blob.size;
                     if (keyOf)
                         toRemember.push([keyOf(item), sha256]);
-                    settle(item, sha256);
+                    arrive(item, sha256);
                 })
                     .catch((error) => {
                     // An abort ends the plan. One file that cannot be READ does not: it is sent
@@ -218,7 +250,7 @@ export async function planUploads(options) {
                         return;
                     }
                     result.stats.hashErrors++;
-                    decide({ kind: "upload", item });
+                    arrive(item, null);
                 })
                     .finally(() => {
                     running--;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cursedbelt-core",
-	"version": "2.14.0",
+	"version": "2.14.1",
 	"license": "ISC",
 	"type": "module",
 	"description": "Framework-agnostic core of the cursedbelt split — isomorphic domain logic. cwip below it, cursedbelt-server and cursedbelt (react) above it.",

package/src/core/upload-precheck/plan.spec.ts

@@ -149,6 +149,42 @@ describe("planUploads", () => {
 		expect(plan.repeats[0].of).toBe(plan.upload[0].item);
 	});
 
+	test("🔴 the FIRST in the drop is the one sent, even when its hash finishes last (forge task 4407)", async () => {
+		const lib = library();
+		const drop = [file("A/song.wav", "same bytes"), file("B/song again.wav", "same bytes"), file("C/other.wav", "diff bytes")];
+		const plan = await planUploads({
+			items: drop,
+			blobOf: (d) => d.blob,
+			ask: (r) => lib.ask(r),
+			// The first file's hash is the slow one — a busy disk, or `crypto.subtle` finishing out of order.
+			hash: async (blob) => {
+				const sha = await sha256OfBlob(blob);
+				if (blob === drop[0]?.blob) await new Promise((r) => setTimeout(r, 30));
+				return sha;
+			},
+		});
+		expect(plan.upload.map((u) => u.item.path).sort()).toEqual(["A/song.wav", "C/other.wav"]);
+		expect(plan.repeats.map((r) => [r.item.path, r.of.path])).toEqual([["B/song again.wav", "A/song.wav"]]);
+	});
+
+	test("…and a first that cannot be read still lets its line move — the copy is sent too", async () => {
+		const drop = [file("A/song.wav", "same bytes"), file("B/song again.wav", "same bytes")];
+		const plan = await planUploads({
+			items: drop,
+			blobOf: (d) => d.blob,
+			ask: async (r) => ({ sizes: r.sizes ?? [], have: {} }),
+			hash: async (blob) => {
+				if (blob === drop[0]?.blob) {
+					await new Promise((r) => setTimeout(r, 30));
+					throw new Error("NotReadableError");
+				}
+				return sha256OfBlob(blob);
+			},
+		});
+		expect(plan.upload.map((u) => u.item.path).sort()).toEqual(["A/song.wav", "B/song again.wav"]);
+		expect(plan.stats.hashErrors).toBe(1);
+	});
+
 	test("a changed modification time is a memo miss — the file is hashed again", async () => {
 		const lib = library();
 		const memo = memoryHashMemo();

package/src/core/upload-precheck/plan.ts

@@ -14,7 +14,11 @@
  *    hashes AS they finish: one request in flight, each carrying every hash completed since the
  *    last. Uploads of the first new files begin while later ones are still being hashed.
  * 4. **A repeat inside the drop** (the same bytes under two names) is caught by its hash without
- *    asking anybody, and only the first is sent.
+ *    asking anybody, and only the first IN THE DROP is sent — never whichever hash happened to
+ *    finish first. Hashes finish out of order (a busy disk, `crypto.subtle` on its own threads), so
+ *    a file's hash is held until every earlier file of its SIZE has one: only those can be its
+ *    repeat, and they started hashing before it did. music's gate went red on exactly that race
+ *    (forge task 4407): "song again.wav" sent and "song.wav" called the copy.
  *
  * A pre-check that FAILS never blocks an upload: the sizes question failing sends everything as
  * it would have before the pre-check existed (each app's own after-the-fact check still stands),
@@ -247,12 +251,38 @@ export async function planUploads<T>(options: PlanOptions<T>): Promise<PlanResul
 		else linger ??= setTimeout(kick, lingerMs);
 	};
 
+	// Step 4's drop order: each size shared inside the drop is a line, in drop order, and a hash
+	// (or a failure to read, `null`) is settled only once everything ahead of it in its line has one.
+	const lines = new Map<number, T[]>();
+	for (const item of candidates) {
+		const size = sizeOf(item);
+		if ((inDrop.get(size) ?? 0) > 1) lines.set(size, [...(lines.get(size) ?? []), item]);
+	}
+	const arrived = new Map<T, string | null>();
+	const apply = (item: T, sha256: string | null): void => {
+		if (sha256 !== null) settle(item, sha256);
+		else decide({ kind: "upload", item });
+	};
+	const arrive = (item: T, sha256: string | null): void => {
+		const line = lines.get(sizeOf(item));
+		if (!line) {
+			apply(item, sha256);
+			return;
+		}
+		arrived.set(item, sha256);
+		while (line.length > 0 && arrived.has(line[0] as T)) {
+			const head = line.shift() as T;
+			apply(head, arrived.get(head) ?? null);
+			arrived.delete(head);
+		}
+	};
+
 	const toHash: T[] = [];
 	for (const item of candidates) {
 		const known = keyOf ? remembered.get(keyOf(item)) : undefined;
 		if (known) {
 			result.stats.memoHits++;
-			settle(item, known);
+			arrive(item, known);
 		} else toHash.push(item);
 	}
 
@@ -282,7 +312,7 @@ export async function planUploads<T>(options: PlanOptions<T>): Promise<PlanResul
 						result.stats.hashedFiles++;
 						result.stats.hashedBytes += blob.size;
 						if (keyOf) toRemember.push([keyOf(item), sha256]);
-						settle(item, sha256);
+						arrive(item, sha256);
 					})
 					.catch((error) => {
 						// An abort ends the plan. One file that cannot be READ does not: it is sent
@@ -294,7 +324,7 @@ export async function planUploads<T>(options: PlanOptions<T>): Promise<PlanResul
 							return;
 						}
 						result.stats.hashErrors++;
-						decide({ kind: "upload", item });
+						arrive(item, null);
 					})
 					.finally(() => {
 						running--;