@mikeargento/bitgraph 1.4.0 → 1.6.0

package/dist/index.d.ts

@@ -15,9 +15,9 @@ export { computeProofHash } from "@mikeargento/bitgraph-verify";
 export { canonicalize, canonicalizeToString, constantTimeEqual } from "@mikeargento/bitgraph-verify";
 export type { HostCapabilities } from "./host.js";
 export { Constructor } from "./constructor.js";
-export { fuse, fuseSet, MAX_SET_MEMBERS, builderFor, FuseError, digestFromBase64, placementForBytes, fusedNamesFor } from "./fuse.js";
+export { fuse, fuseSet, MAX_SET_MEMBERS, trailerBytesFor, builderFor, FuseError, digestFromBase64, placementForBytes, fusedNamesFor } from "./fuse.js";
 export type { FuseBuilder, BuilderInput, FuseOptions, FuseResult, FuseTransport, FuseErrorCode } from "./fuse.js";
-export type { FuseSetMember, SetMemberPlacement, FuseSetOptions, FuseSetMemberResult, FuseSetResult } from "./fuse.js";
+export type { FuseSetMember, FuseSetBytesMember, FuseSetLoadedMember, FuseSetHashedMember, FusedDigestInput, SetMemberPlacement, FuseSetOptions, FuseSetProgress, FuseSetMemberResult, FuseSetResult } from "./fuse.js";
 export type { FuseFrame, PlacementId, SetManifest, FuseMemberResult, FuseVerifyResult } from "@mikeargento/bitgraph-verify";
 export { parsePolicy, hashPolicy, createPolicyBinding, validateAction, } from "./policy.js";
 export type { PolicyDocument, PolicyRules, ActionValidationResult, } from "./policy.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAGH,YAAY,EACV,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,GACf,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGrG,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAK/C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACtI,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAClH,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAEvH,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAG5H,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,cAAc,EACd,WAAW,EACX,sBAAsB,GACvB,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAGH,YAAY,EACV,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,GACf,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGrG,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAK/C,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACvJ,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAClH,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAExN,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAG5H,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,cAAc,EACd,WAAW,EACX,sBAAsB,GACvB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -7,7 +7,7 @@ export { Constructor } from "./constructor.js";
 // The producer profile over the primitive (working name Fuse): allocate a
 // slot, write a commitment to it into the artifact, hash, commit under the
 // same slot. The resulting proof is ordinary bitgraph/1.
-export { fuse, fuseSet, MAX_SET_MEMBERS, builderFor, FuseError, digestFromBase64, placementForBytes, fusedNamesFor } from "./fuse.js";
+export { fuse, fuseSet, MAX_SET_MEMBERS, trailerBytesFor, builderFor, FuseError, digestFromBase64, placementForBytes, fusedNamesFor } from "./fuse.js";
 // Policy parsing, hashing, and validation
 export { parsePolicy, hashPolicy, createPolicyBinding, validateAction, } from "./policy.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gEAAgE;AA4BhE,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAE3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAKrG,2BAA2B;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,0EAA0E;AAC1E,2EAA2E;AAC3E,yDAAyD;AACzD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAMtI,0CAA0C;AAC1C,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gEAAgE;AA4BhE,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAE3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAKrG,2BAA2B;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,0EAA0E;AAC1E,2EAA2E;AAC3E,yDAAyD;AACzD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,UAAU,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAMvJ,0CAA0C;AAC1C,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeargento/bitgraph",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Portable cryptographic proof of construction for digital artifacts.",
   "type": "module",

package/src/__tests__/fuse-set-sdk.test.ts

@@ -32,7 +32,8 @@ import {
 import type { BitGraphProof, SlotAllocation, Attribution, SetMember, SetManifest } from "@mikeargento/bitgraph-verify";
 import { makeKey, signBody, b64, utf8 } from "./audit-fixtures.js";
 import type { ManualKey } from "./audit-fixtures.js";
-import { fuse, fuseSet, builderFor, placementForBytes, fusedNamesFor, FuseError, MAX_SET_MEMBERS } from "../fuse.js";
+import { fuse, fuseSet, builderFor, placementForBytes, fusedNamesFor, FuseError, MAX_SET_MEMBERS, digest, trailerBytesFor } from "../fuse.js";
+import type { FuseSetProgress, FuseSetBytesMember, FuseSetLoadedMember, FuseSetHashedMember, FusedDigestInput } from "../fuse.js";
 import type { FuseSetMember } from "../fuse.js";
 
 const FIX = fileURLToPath(new URL("../../src/__tests__/fuse-fixtures/", import.meta.url));
@@ -47,7 +48,7 @@ const unrelated = utf8("a file nobody recorded\n");
 // The phase-1 fixtures fuse original.txt as trailer/1 and image.png as
 // container/1, so these members declare those placements; the by-bytes
 // default (placementForBytes) is asserted on its own in test 3.
-const two = (): FuseSetMember[] => [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
+const two = (): FuseSetBytesMember[] => [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
 
 // ---------------------------------------------------------------------------
 // Local signer: slots and proofs minted from a received commit body
@@ -159,9 +160,9 @@ const toUrlSafe = (s: string) => s.replace(/\+/g, "-").replace(/\//g, "_").repla
 interface Oracle { commitment: Uint8Array; fused: Uint8Array[]; rows: SetMember[]; manifest: Uint8Array; digestB64: string; sorted: SetMember[] }
 
 /** The commitment from the slot, each member built by its placement, the canonical manifest and its digest. */
-function oracle(slot: SlotAllocation, members: readonly FuseSetMember[]): Oracle {
+function oracle(slot: SlotAllocation, members: readonly FuseSetBytesMember[]): Oracle {
   const commitment = computeSlotCommitment(slot);
-  const placementOf = (m: FuseSetMember) => m.placement ?? placementForBytes(m.original);
+  const placementOf = (m: FuseSetBytesMember) => m.placement ?? placementForBytes(m.original);
   const fused = members.map((m) => getPlacement(placementOf(m))!.build({ original: m.original, commitment }));
   const rows = members.map((m, i) => ({ artifact: sha256(fused[i]!), origin: sha256(m.original), placement: placementOf(m) }));
   const manifest = buildSetManifest(commitment, rows);
@@ -229,11 +230,11 @@ describe("fuseSet(): one slot, N files, the manifest as the artifact", () => {
     assert.equal(r.proof.attribution?.title, "set/1");
   });
 
-  test("3. members come back in the caller's order, each with its manifest row, its names, and SET_MEMBER_DIRECT against explicit bytes", async () => {
+  test("3. members come back in the caller's order, each with its manifest row and its names; with verifyMembers each is SET_MEMBER_DIRECT against explicit bytes", async () => {
     const members = two();
     members[0]!.name = "photo.jpg";
     const o = oracle(slot, members);
-    const r = await fuseSet(members, { transport: honest(key, slot).transport });
+    const r = await fuseSet(members, { transport: honest(key, slot).transport, verifyMembers: true });
     assert.deepEqual(r.members.map((m) => m.index), [0, 1]);
     for (const m of r.members) {
       const row = o.rows[m.index]!;
@@ -241,13 +242,17 @@ describe("fuseSet(): one slot, N files, the manifest as the artifact", () => {
       assert.equal(m.originDigestB64, bytesToBase64(row.origin));
       assert.equal(m.artifactDigestB64, bytesToBase64(row.artifact));
       assert.equal(m.manifestIndex, o.sorted.findIndex((s) => bytesToHex(s.artifact) === bytesToHex(row.artifact)));
-      assert.equal(m.manifestIndex, m.verification.set!.member!.index);
+      assert.equal(m.manifestIndex, m.verification!.set!.member!.index);
       assert.ok(!("fusedBytes" in m), "not kept by default");
-      assert.equal(m.verification.category, "SET_MEMBER_DIRECT", m.verification.reason ?? "");
-      assert.equal(m.verification.set!.manifestSource, "argument");
-      assert.equal(m.verification.set!.member!.fusedDigestB64, m.artifactDigestB64);
-      assert.equal(m.verification.set!.memberCount, 2);
+      assert.equal(m.verification!.category, "SET_MEMBER_DIRECT", m.verification!.reason ?? "");
+      assert.equal(m.verification!.set!.manifestSource, "argument");
+      assert.equal(m.verification!.set!.member!.fusedDigestB64, m.artifactDigestB64);
+      assert.equal(m.verification!.set!.memberCount, 2);
     }
+    // Without verifyMembers the same rows come back bound by digest, and no verdict is invented.
+    const plain = await fuseSet(members, { transport: honest(key, slot).transport });
+    assert.deepEqual(plain.members.map((m) => [m.index, m.manifestIndex, m.placement, m.originDigestB64, m.artifactDigestB64]), r.members.map((m) => [m.index, m.manifestIndex, m.placement, m.originDigestB64, m.artifactDigestB64]));
+    for (const m of plain.members) assert.ok(!("verification" in m), "no verifier verdict without verifyMembers");
     assert.deepEqual({ fusedName: r.members[0]!.fusedName, frameName: r.members[0]!.frameName }, fusedNamesFor("photo.jpg", "trailer/1"));
     assert.equal(r.members[1]!.fusedName, null);
     assert.equal(r.members[1]!.frameName, null);
@@ -331,7 +336,7 @@ describe("fuseSet(): a bad member burns the slot and commits nothing", () => {
   test("9. bytes that carry the commitment but embed another member's origin are builder-failed naming the member and the origin", async () => {
     const { calls, transport } = honest(key, slot);
     // Two trailer/1 members; member 1's builder hands back member 0's fused bytes, which carry c but embed member 0's original.
-    const members: FuseSetMember[] = [{ original, placement: "trailer/1" }, { original: note, placement: "trailer/1" }];
+    const members: FuseSetBytesMember[] = [{ original, placement: "trailer/1" }, { original: note, placement: "trailer/1" }];
     members[1]!.builder = ({ commitment }) => getPlacement("trailer/1")!.build({ original, commitment });
     await assert.rejects(fuseSet(members, { transport }), (e: FuseError) => e.code === "builder-failed" && /member 1/.test(e.message) && /origin/.test(e.message) && e.member === 1);
     assert.equal(commits(calls).length, 0);
@@ -340,21 +345,21 @@ describe("fuseSet(): a bad member burns the slot and commits nothing", () => {
 
   test("9b. container/1: bytes that declare the member's origin digest but carry other bytes are builder-failed naming the member; no commit", async () => {
     const { calls, transport } = honest(key, slot);
-    const members: FuseSetMember[] = [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
+    const members: FuseSetBytesMember[] = [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
     // The payload names png's digest (so the declared origin matches) while the tar carries other bytes.
     members[1]!.builder = ({ commitment, originDigest }) => getPlacement("container/1")!.build({ original: utf8("not the member's original\n"), originDigest: originDigest!, commitment });
     await assert.rejects(fuseSet(members, { transport }), (e: FuseError) => e.code === "builder-failed" && /^member 1/.test(e.message) && /origin/.test(e.message) && e.member === 1);
     assert.equal(commits(calls).length, 0, "nothing was committed");
     assert.equal(allocates(calls).length, 1);
     // The mirror: a payload declaring another digest over the member's own bytes is refused the same way.
-    const declared: FuseSetMember[] = [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
+    const declared: FuseSetBytesMember[] = [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }];
     declared[1]!.builder = ({ commitment }) => getPlacement("container/1")!.build({ original: png, originDigest: sha256(unrelated), commitment });
     const b = honest(key, slot);
     await assert.rejects(fuseSet(declared, { transport: b.transport }), (e: FuseError) => e.code === "builder-failed" && e.member === 1);
     assert.equal(commits(b.calls).length, 0);
     // And the honest container/1 builder still passes both checks.
-    const ok = await fuseSet([{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }], { transport: honest(key, slot).transport });
-    assert.equal(ok.members[1]!.verification.category, "SET_MEMBER_DIRECT");
+    const ok = await fuseSet([{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }], { transport: honest(key, slot).transport, verifyMembers: true });
+    assert.equal(ok.members[1]!.verification!.category, "SET_MEMBER_DIRECT");
   });
 });
 
@@ -370,12 +375,12 @@ describe("fuseSet(): bad input is refused before any request", () => {
       (e: FuseError) => e.code === "bad-input" && /members 0 and 2/.test(e.message) && e.member === 2,
     );
     assert.equal(calls.length, 0, "no slot was burned");
-    const r = await fuseSet([{ original, placement: "trailer/1" }, { original, placement: "container/1" }], { transport });
+    const r = await fuseSet([{ original, placement: "trailer/1" }, { original, placement: "container/1" }], { transport, verifyMembers: true });
     assert.equal(r.manifest.members.length, 2);
     assert.deepEqual(r.members.map((m) => m.placement), ["trailer/1", "container/1"]);
     assert.equal(r.members[0]!.originDigestB64, r.members[1]!.originDigestB64);
     assert.notEqual(r.members[0]!.artifactDigestB64, r.members[1]!.artifactDigestB64);
-    for (const m of r.members) assert.equal(m.verification.category, "SET_MEMBER_DIRECT");
+    for (const m of r.members) assert.equal(m.verification!.category, "SET_MEMBER_DIRECT");
   });
 
   test("11. an empty set and a set over the cap are refused; the cap runs before the duplicate check", async () => {
@@ -454,14 +459,14 @@ describe("fuseSet(): the boundary", () => {
       () => { throw new Error("socket hang up"); },
       () => ({ status: 200, json: { proofs: [{ proof: decoy }, { proof: real }] } }),
     );
-    const r = await fuseSet(two(), { transport });
+    const r = await fuseSet(two(), { transport, verifyMembers: true });
     assert.equal(r.recovered, true);
     assert.deepEqual(r.proof, real);
     assert.equal(allocates(calls).length, 1);
     const lookup = calls.find((c) => c.path.startsWith("/api/proofs/"))!;
     assert.ok(lookup.path.includes(toUrlSafe(o.digestB64)), lookup.path);
     assert.equal(r.manifestEchoed, true);
-    for (const m of r.members) assert.equal(m.verification.category, "SET_MEMBER_DIRECT");
+    for (const m of r.members) assert.equal(m.verification!.category, "SET_MEMBER_DIRECT");
   });
 
   test("16. 409 slot-unavailable: read back when the ledger has the proof, else reported as slot-unavailable and never retried into a new slot", async () => {
@@ -503,32 +508,40 @@ describe("fuseSet(): the boundary", () => {
 // ---------------------------------------------------------------------------
 
 describe("fuseSet(): the result and the checks before it is returned", () => {
-  test("19. keepFused returns each member's fused bytes; false and the default do not; the verification is present either way", async () => {
+  test("19. keepFused returns each member's fused bytes; false and the default do not; the verifier's verdict only with verifyMembers", async () => {
     const members = two();
     const commitment = computeSlotCommitment(slot);
-    const kept = await fuseSet(members, { transport: honest(key, slot).transport, keepFused: true });
+    const kept = await fuseSet(members, { transport: honest(key, slot).transport, keepFused: true, verifyMembers: true });
     for (const m of kept.members) {
       assert.deepEqual(m.fusedBytes, getPlacement(m.placement)!.build({ original: members[m.index]!.original, commitment }));
-      assert.equal(m.verification.category, "SET_MEMBER_DIRECT");
+      assert.equal(m.verification!.category, "SET_MEMBER_DIRECT");
+    }
+    const keptOnly = await fuseSet(members, { transport: honest(key, slot).transport, keepFused: true });
+    for (const m of keptOnly.members) {
+      assert.deepEqual(m.fusedBytes, getPlacement(m.placement)!.build({ original: members[m.index]!.original, commitment }));
+      assert.ok(!("verification" in m));
     }
     for (const opts of [{ keepFused: false }, {}]) {
       const r = await fuseSet(members, { transport: honest(key, slot).transport, ...opts });
       for (const m of r.members) {
         assert.ok(!("fusedBytes" in m));
-        assert.equal(m.verification.category, "SET_MEMBER_DIRECT");
+        assert.ok(!("verification" in m));
       }
     }
   });
 
-  test("20. a boundary that does not echo the manifest: success, manifestEchoed false, every member verified against the explicit bytes", async () => {
-    const r = await fuseSet(two(), { transport: honest(key, slot, { withMetadata: false }).transport });
+  test("20. a boundary that does not echo the manifest: success, manifestEchoed false, and with verifyMembers every member verified against the explicit bytes", async () => {
+    const r = await fuseSet(two(), { transport: honest(key, slot, { withMetadata: false }).transport, verifyMembers: true });
     assert.equal(r.manifestEchoed, false);
     assert.equal(r.proof.metadata, undefined);
     assert.equal(r.verification.category, "FUSED_DIRECT");
     for (const m of r.members) {
-      assert.equal(m.verification.category, "SET_MEMBER_DIRECT", m.verification.reason ?? "");
-      assert.equal(m.verification.set!.manifestSource, "argument");
+      assert.equal(m.verification!.category, "SET_MEMBER_DIRECT", m.verification!.reason ?? "");
+      assert.equal(m.verification!.set!.manifestSource, "argument");
     }
+    const plain = await fuseSet(two(), { transport: honest(key, slot, { withMetadata: false }).transport });
+    assert.equal(plain.manifestEchoed, false);
+    assert.equal(plain.members.length, 2);
   });
 
   test("21. an echoed manifest that differs from the committed one is verification-failed; no result", async () => {
@@ -589,7 +602,7 @@ describe("wiring", () => {
     for (const name of ["SetManifest", "FuseMemberResult", "FuseVerifyResult", "FuseFrame", "PlacementId"]) assert.ok(typeExports.includes(name), `index.ts re-exports type ${name}`);
   });
 
-  test("26. FUSE.md: Sets is its own subsection, the echo is stated as absent on every production boundary, and the return-time cost is stated", () => {
+  test("26. FUSE.md: Sets is its own subsection, the echo is stated per boundary, and the return-time binding and its costs are stated", () => {
     const doc = readFileSync(fileURLToPath(new URL("../../docs/fuse/FUSE.md", import.meta.url)), "utf8");
     const headings = [...doc.matchAll(/^(##+) (.+)$/gm)].map((m) => `${m[1]} ${m[2]}`);
     const sets = headings.indexOf("### Sets");
@@ -599,9 +612,15 @@ describe("wiring", () => {
     const setsText = doc.slice(doc.indexOf("### Sets"), doc.indexOf("### Harness"));
     assert.ok(!setsText.includes("Bounded copy, verbatim"), "no bounded copy inside Sets");
     assert.ok(!/the parent and the enclave do echo/.test(doc), "the parent path does not echo the manifest");
-    assert.match(setsText, /No production boundary returns the echo today/);
-    assert.match(setsText, /parent-direct returns `manifestEchoed:\s+false`/);
-    assert.match(setsText, /grows with the square of the member count/);
+    assert.match(setsText, /Enclave v6 .*keeps metadata on a held-slot commit/s);
+    assert.match(setsText, /returns\s+`manifestEchoed:\s+true`/);
+    assert.match(setsText, /drops\s+metadata\s+returns\s+`manifestEchoed:\s+false`/);
+    assert.match(setsText, /bound to it by digest/);
+    assert.match(setsText, /`verifyMembers: true`/);
+    assert.match(setsText, /grows\s+with\s+the\s+square\s+of\s+the\s+member\s+count/);
+    assert.match(setsText, /native SHA-256/);
+    assert.match(setsText, /one fused copy/);
+    assert.match(setsText, /`onProgress`/);
     assert.match(setsText, /after the commit, so the slot TTL is not\s+at risk/);
     assert.ok(!doc.includes("\u2014"), "no em dashes");
   });
@@ -636,3 +655,154 @@ describe("wiring", () => {
     }
   });
 });
+
+describe("fuseSet(): hashing and progress", () => {
+  test("28. digest(): the native hasher and the library agree at every size, and the library answers when the platform has no hasher or refuses the input", async () => {
+    for (const n of [0, 1, 55, 56, 63, 64, 65, 1000, 70_000, 1_000_003]) {
+      const b = new Uint8Array(n);
+      for (let i = 0; i < n; i++) b[i] = (i * 7 + n) & 0xff;
+      assert.equal(bytesToHex(await digest(b)), bytesToHex(sha256(b)), `size ${n}`);
+    }
+    const sample = utf8("a member hashed without WebCrypto\n");
+    const want = bytesToHex(sha256(sample));
+    const desc = Object.getOwnPropertyDescriptor(globalThis, "crypto")!;
+    try {
+      Object.defineProperty(globalThis, "crypto", { value: undefined, configurable: true, writable: true });
+      assert.equal(bytesToHex(await digest(sample)), want, "no platform hasher: the library");
+      Object.defineProperty(globalThis, "crypto", { value: { subtle: { digest: () => Promise.reject(new TypeError("refused")) } }, configurable: true, writable: true });
+      assert.equal(bytesToHex(await digest(sample)), want, "a refusing platform hasher: the library");
+    } finally {
+      Object.defineProperty(globalThis, "crypto", desc);
+    }
+    assert.equal(bytesToHex(await digest(sample)), want, "restored");
+  });
+
+  test("29. onProgress: hash and fuse per member before and after the slot, commit 0 of 1 then 1 of 1, verify only with verifyMembers; a throwing hook changes nothing", async () => {
+    const members: FuseSetMember[] = [...two(), { original: note, placement: "container/1" }];
+    const seen: FuseSetProgress[] = [];
+    const r = await fuseSet(members, { transport: honest(key, slot).transport, onProgress: (p) => seen.push({ ...p }) });
+    assert.equal(r.members.length, 3);
+    const of = (phase: FuseSetProgress["phase"]) => seen.filter((p) => p.phase === phase).map((p) => `${p.done}/${p.total}`);
+    assert.deepEqual(of("hash"), ["1/3", "2/3", "3/3"]);
+    assert.deepEqual(of("fuse"), ["1/3", "2/3", "3/3"]);
+    assert.deepEqual(of("commit"), ["0/1", "1/1"]);
+    assert.deepEqual(of("verify"), []);
+    assert.deepEqual(seen.map((p) => p.phase), ["hash", "hash", "hash", "fuse", "fuse", "fuse", "commit", "commit"], "hash before the slot, fuse after it, then the commit");
+    const verified: FuseSetProgress[] = [];
+    await fuseSet(members, { transport: honest(key, slot).transport, verifyMembers: true, onProgress: (p) => verified.push({ ...p }) });
+    assert.deepEqual(verified.filter((p) => p.phase === "verify").map((p) => `${p.done}/${p.total}`), ["1/3", "2/3", "3/3"]);
+    assert.equal(verified.findIndex((p) => p.phase === "verify") > verified.findIndex((p) => p.phase === "commit" && p.done === 1), true, "verify after the commit");
+    let calls = 0;
+    const thrown = await fuseSet(members, { transport: honest(key, slot).transport, onProgress: () => { calls++; throw new Error("a hook that throws"); } });
+    assert.equal(thrown.members.length, 3);
+    assert.equal(calls, 8, "every report was attempted");
+  });
+});
+
+describe("fuseSet(): loaded and hashed members", () => {
+  /** The trailer/1 member finished from a hasher state, as a scanner does: hash the original once, keep the state, add the trailer later. */
+  const savedState = (bytes: Uint8Array) => { const h = sha256.create(); h.update(bytes); return h; };
+  const finish = (h: ReturnType<typeof sha256.create>, trailer: Uint8Array) => { const c = h.clone(); c.update(trailer); return c.digest(); };
+
+  test("30. trailerBytesFor is the placement's own suffix: original followed by it hashes to the trailer/1 build, and a saved state finished with it agrees", () => {
+    const commitment = computeSlotCommitment(slot);
+    const t = trailerBytesFor(commitment);
+    assert.equal(t.length, 48);
+    assert.deepEqual(t.subarray(0, 8), utf8("BGFUSE01"));
+    assert.deepEqual(t.subarray(8, 16), new Uint8Array(8));
+    assert.deepEqual(t.subarray(16), commitment);
+    for (const o of [original, png, note, new Uint8Array(0), new Uint8Array(55).fill(1), new Uint8Array(64).fill(2), new Uint8Array(1_000_003).fill(3)]) {
+      const built = getPlacement("trailer/1")!.build({ original: o, commitment });
+      assert.deepEqual(built.subarray(o.length), t, `suffix for ${o.length} bytes`);
+      assert.deepEqual(finish(savedState(o), t), sha256(built), `finished state for ${o.length} bytes`);
+    }
+    assert.throws(() => trailerBytesFor(new Uint8Array(31)), (e: FuseError) => e.code === "bad-input");
+  });
+
+  test("31. a loaded member is read once, after the slot is held, checked against its named digest, and released unless kept", async () => {
+    const { calls, transport } = honest(key, slot);
+    const order: string[] = [];
+    const wrapped = { ...transport, fetch: async (url: string, init?: RequestInit) => { order.push(new URL(url).pathname); return (transport.fetch as (u: string, i?: RequestInit) => Promise<Response>)(url, init); } } as unknown as typeof transport;
+    let loads = 0;
+    const loaded: FuseSetLoadedMember = { load: async () => { loads++; order.push("load"); return original; }, originDigest: sha256(original), placement: "trailer/1", name: "photo.jpg" };
+    const r = await fuseSet([loaded, { original: png, placement: "container/1" }], { transport: wrapped });
+    assert.equal(loads, 1);
+    assert.ok(order.indexOf("load") > order.indexOf("/api/fuse/allocate"), "read after the slot is held");
+    assert.ok(order.indexOf("load") < order.indexOf("/api/fuse/commit"), "read before the commit");
+    const o = oracle(slot, [{ original, placement: "trailer/1" }, { original: png, placement: "container/1" }]);
+    assert.equal(r.members[0]!.artifactDigestB64, bytesToBase64(o.rows[0]!.artifact));
+    assert.equal(r.members[0]!.originDigestB64, bytesToBase64(sha256(original)));
+    assert.equal(r.members[0]!.fusedName, fusedNamesFor("photo.jpg", "trailer/1").fusedName);
+    assert.ok(!("fusedBytes" in r.members[0]!));
+    assert.equal(commits(calls).length, 1);
+    const kept = await fuseSet([{ ...loaded }], { transport: honest(key, slot).transport, keepFused: true });
+    assert.deepEqual(kept.members[0]!.fusedBytes, getPlacement("trailer/1")!.build({ original, commitment: computeSlotCommitment(slot) }));
+    // A wrong named digest burns the slot and commits nothing.
+    const bad = honest(key, slot);
+    await assert.rejects(fuseSet([{ load: () => original, originDigest: sha256(unrelated), placement: "trailer/1" }], { transport: bad.transport }), (e: FuseError) => e.code === "bad-input" && /^member 0: originDigest is not the SHA-256 of the loaded bytes/.test(e.message) && e.member === 0);
+    assert.equal(commits(bad.calls).length, 0);
+    assert.equal(allocates(bad.calls).length, 1);
+    // A loader that throws, or returns something other than bytes, is load-failed naming the member.
+    const thrown = honest(key, slot);
+    await assert.rejects(fuseSet([{ load: () => { throw new Error("gone"); }, originDigest: sha256(original), placement: "trailer/1" }], { transport: thrown.transport }), (e: FuseError) => e.code === "load-failed" && /^member 0: load threw: gone/.test(e.message) && e.member === 0);
+    assert.equal(commits(thrown.calls).length, 0);
+    await assert.rejects(fuseSet([{ original, placement: "trailer/1" }, { load: (() => "text") as never, originDigest: sha256(original), placement: "container/1" }], { transport: honest(key, slot).transport }), (e: FuseError) => e.code === "load-failed" && /^member 1: load must return a Uint8Array/.test(e.message) && e.member === 1);
+    // Without a placement or a digest nothing is requested.
+    const quiet = honest(key, slot);
+    await assert.rejects(fuseSet([{ load: () => original, originDigest: sha256(original) } as never], { transport: quiet.transport }), (e: FuseError) => e.code === "bad-input" && /^member 0: a loaded member names its placement/.test(e.message));
+    await assert.rejects(fuseSet([{ load: () => original, placement: "trailer/1" } as never], { transport: quiet.transport }), (e: FuseError) => e.code === "bad-input" && /^member 0: a loaded member names its originDigest/.test(e.message));
+    assert.equal(quiet.calls.length, 0);
+  });
+
+  test("32. a hashed member answers its fused digest for the held commitment and never shows its bytes; the row is what the real verifier finds", async () => {
+    const { calls, transport } = honest(key, slot);
+    const inputs: FusedDigestInput[] = [];
+    const state = savedState(original);
+    const hashed: FuseSetHashedMember = {
+      originDigest: sha256(original),
+      placement: "trailer/1",
+      name: "photo.jpg",
+      fusedDigest: (input) => { inputs.push(input); return finish(state, trailerBytesFor(input.commitment)); },
+    };
+    const r = await fuseSet([hashed, { original: png, placement: "container/1" }, { load: () => note, originDigest: sha256(note), placement: "container/1" }], { transport, keepFused: true });
+    assert.equal(inputs.length, 1);
+    const commitment = computeSlotCommitment(slot);
+    assert.deepEqual(inputs[0]!.commitment, commitment);
+    assert.equal(inputs[0]!.commitmentHex, bytesToHex(commitment));
+    assert.equal(inputs[0]!.slot.nonceB64, slot.nonceB64);
+    const built = getPlacement("trailer/1")!.build({ original, commitment });
+    assert.equal(r.members[0]!.artifactDigestB64, bytesToBase64(sha256(built)), "the row is the hash of the placement's build");
+    assert.ok(!("fusedBytes" in r.members[0]!), "nothing to keep for a hashed member");
+    assert.ok("fusedBytes" in r.members[1]! && "fusedBytes" in r.members[2]!, "bytes and loaded members are kept");
+    assert.equal(r.members.length, 3);
+    assert.equal(r.manifest.members.length, 3);
+    assert.equal(commits(calls).length, 1);
+    // The real verifier reads the member from the bytes a reader would build, and from its original.
+    const direct = await verifyFuseMember({ proof: r.proof, bytes: built, manifest: r.manifestBytes });
+    assert.equal(direct.category, "SET_MEMBER_DIRECT", direct.reason ?? "");
+    assert.equal(direct.set!.member!.index, r.members[0]!.manifestIndex);
+    const fromOrigin = await verifyFuseMember({ proof: r.proof, bytes: original, manifest: r.manifestBytes });
+    assert.equal(fromOrigin.category, "SET_MEMBER_FROM_ORIGIN", fromOrigin.reason ?? "");
+    // verifyMembers refuses a hashed member before any request; a throwing or short answer is builder-failed naming the member.
+    const quiet = honest(key, slot);
+    await assert.rejects(fuseSet([hashed], { transport: quiet.transport, verifyMembers: true }), (e: FuseError) => e.code === "bad-input" && /^member 0: a hashed member cannot be verified in full/.test(e.message) && e.member === 0);
+    assert.equal(quiet.calls.length, 0);
+    const throwing = honest(key, slot);
+    await assert.rejects(fuseSet([{ ...hashed, fusedDigest: () => { throw new Error("no state"); } }], { transport: throwing.transport }), (e: FuseError) => e.code === "builder-failed" && /^member 0: fusedDigest threw: no state/.test(e.message) && e.member === 0);
+    assert.equal(commits(throwing.calls).length, 0);
+    await assert.rejects(fuseSet([{ ...hashed, fusedDigest: () => new Uint8Array(31) }], { transport: honest(key, slot).transport }), (e: FuseError) => e.code === "builder-failed" && /^member 0: fusedDigest must return a 32-byte digest/.test(e.message));
+    // The same original as a hashed member and as a bytes member under one placement is the duplicate it always was.
+    await assert.rejects(fuseSet([hashed, { original, placement: "trailer/1" }], { transport: honest(key, slot).transport }), (e: FuseError) => e.code === "bad-input" && /^members 0 and 1 are the same original/.test(e.message));
+  });
+
+  test("33. progress counts every shape: hash before the slot for all three, fuse after it, one commit", async () => {
+    const seen: FuseSetProgress[] = [];
+    const state = savedState(original);
+    await fuseSet([
+      { originDigest: sha256(original), placement: "trailer/1", fusedDigest: ({ commitment }) => finish(state, trailerBytesFor(commitment)) },
+      { load: () => note, originDigest: sha256(note), placement: "container/1" },
+      { original: png, placement: "container/1" },
+    ], { transport: honest(key, slot).transport, onProgress: (p) => seen.push({ ...p }) });
+    assert.deepEqual(seen.map((p) => `${p.phase} ${p.done}/${p.total}`), ["hash 1/3", "hash 2/3", "hash 3/3", "fuse 1/3", "fuse 2/3", "fuse 3/3", "commit 0/1", "commit 1/1"]);
+  });
+});

package/src/fuse-cli.ts

@@ -149,7 +149,8 @@ async function runSet(args: Args): Promise<number> {
       seen.set(fusedName, i);
     }
   }
-  const r = await fuseSet(members, { keepFused: keep, transport: transportFrom(args.flags) });
+  // The harness reads every member with the full verifier; the site binds by digest.
+  const r = await fuseSet(members, { keepFused: keep, verifyMembers: true, transport: transportFrom(args.flags) });
   const outDir = outDirOf(args);
   await mkdir(outDir, { recursive: true });
   const written: string[] = [];
@@ -166,7 +167,7 @@ async function runSet(args: Args): Promise<number> {
     written.push(p);
   }
   report(r.proof, r.verification.category, r.recovered, false);
-  for (const m of r.members) process.stdout.write(`member ${m.index}  row ${m.manifestIndex}  ${m.placement}  ${m.verification.category}  ${m.fusedName ?? ""}\n`);
+  for (const m of r.members) process.stdout.write(`member ${m.index}  row ${m.manifestIndex}  ${m.placement}  ${m.verification?.category ?? "listed"}  ${m.fusedName ?? ""}\n`);
   if (!r.manifestEchoed) process.stdout.write(`note  the proof does not carry the manifest; keep set.manifest.json beside it\n`);
   process.stdout.write(`\nwrote:\n${written.map((w) => "  " + w).join("\n")}\n`);
   return 0;