@mikeargento/bitgraph 1.9.0 → 1.9.1

package/src/__tests__/fuse-inline.test.ts

@@ -0,0 +1,211 @@
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
+
+/**
+ * The marker's title in its second vocabulary: an ENCODING rather than a
+ * placement, for an artifact MADE with the commitment inside it.
+ *
+ * A placement is a recipe, so a holder of the original rebuilds the committed
+ * artifact byte for byte. An encoding says there is no recipe and no original:
+ * the commitment was in the thing while it was being made (a prompt, a build
+ * id, a commit message), so the only thing to do is look for it. One marker
+ * answers both, which is why this file tests verifyFuse and not a second
+ * function. It was briefly a second profile, bitgraph-run/1, on 2026-09-07.
+ *
+ * The positive case is real: the canonical inline artifact minted on
+ * production, enclave v8, slot 2072 consumed at commit 2075. Categories that
+ * need a key under this test's control mint their own proofs, because every one
+ * of them is reached by changing something the enclave signed.
+ */
+
+import { describe, test } from "node:test";
+import * as assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { sha256 } from "@noble/hashes/sha256";
+import { getPublicKeyAsync, signAsync, utils } from "@noble/ed25519";
+import {
+  verifyFuse,
+  inlineAttribution,
+  isCarryEncoding,
+  findCommitment,
+  computeSlotCommitment,
+  canonicalize,
+  bytesToBase64,
+  ENCODING_BASE64URL,
+} from "@mikeargento/bitgraph-verify";
+import type { BitGraphProof } from "@mikeargento/bitgraph-verify";
+
+const FIX = fileURLToPath(new URL("../../src/__tests__/fuse-fixtures/", import.meta.url));
+const b64 = (b: Uint8Array) => bytesToBase64(b);
+const b64u = (b: Uint8Array) => b64(b).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+const utf8 = (s: string) => new TextEncoder().encode(s);
+
+const liveProof = JSON.parse(readFileSync(FIX + "inline.proof.json", "utf8")) as BitGraphProof;
+const liveBytes = new Uint8Array(readFileSync(FIX + "inline.artifact.txt"));
+
+/** Mint a proof the way the enclave does, so the signature covers the marker. */
+async function mint(
+  makeBytes: (commitment: string) => Uint8Array,
+  opts: { title?: string; message?: string } = {},
+) {
+  const seed = utils.randomPrivateKey();
+  const publicKeyB64 = b64(await getPublicKeyAsync(seed));
+  const slotBody = {
+    version: "bitgraph/slot/1" as const,
+    nonceB64: b64(new Uint8Array(32).fill(7)),
+    counter: "41",
+    epochId: "inline-test-epoch",
+    publicKeyB64,
+  };
+  const slotAllocation = { ...slotBody, signatureB64: b64(await signAsync(canonicalize(slotBody), seed)) };
+  const commitment = b64u(computeSlotCommitment(slotAllocation));
+  const bytes = makeBytes(commitment);
+  const digestB64 = b64(sha256(bytes));
+  const attribution: Record<string, string> = { name: "bitgraph-fuse/1", title: opts.title ?? ENCODING_BASE64URL };
+  if (opts.message !== undefined) attribution["message"] = opts.message;
+  const commit = {
+    nonceB64: slotBody.nonceB64,
+    counter: "42",
+    slotCounter: "41",
+    slotHashB64: b64(sha256(canonicalize(slotBody))),
+    epochId: "inline-test-epoch",
+  };
+  const signedBody = {
+    version: "bitgraph/1" as const,
+    artifact: { hashAlg: "sha256" as const, digestB64 },
+    commit,
+    publicKeyB64,
+    enforcement: "measured-tee" as const,
+    measurement: "inline-test-measurement",
+    attribution,
+  };
+  const proof = {
+    version: "bitgraph/1",
+    artifact: signedBody.artifact,
+    commit,
+    signer: { publicKeyB64, signatureB64: b64(await signAsync(canonicalize(signedBody), seed)) },
+    environment: { enforcement: "measured-tee", measurement: "inline-test-measurement" },
+    slotAllocation,
+    attribution,
+  } as unknown as BitGraphProof;
+  return { proof, bytes, commitment };
+}
+
+describe("carry encodings", () => {
+  test("base64url is registered; a placement id and nonsense are not", () => {
+    assert.equal(isCarryEncoding(ENCODING_BASE64URL), true);
+    for (const id of ["trailer/1", "container/2", "set/1", "hex/1", "", null, undefined]) {
+      assert.equal(isCarryEncoding(id as string), false, `${String(id)} should not be an encoding`);
+    }
+  });
+
+  test("inlineAttribution declares the encoding and no origin, because there is none", () => {
+    const a = inlineAttribution();
+    assert.deepEqual(a, { name: "bitgraph-fuse/1", title: ENCODING_BASE64URL });
+    assert.equal("message" in a, false, "a 32-byte message would be read as an origin digest");
+    assert.deepEqual(a, liveProof.attribution);
+  });
+
+  test("findCommitment locates every occurrence, and none for an unregistered encoding", () => {
+    const c = new Uint8Array(32).fill(3);
+    const text = b64u(c);
+    assert.deepEqual(findCommitment(utf8(`a${text}b${text}`), c, ENCODING_BASE64URL), [1, 1 + text.length + 1]);
+    assert.deepEqual(findCommitment(utf8("nothing"), c, ENCODING_BASE64URL), []);
+    assert.deepEqual(findCommitment(utf8(text), c, "hex/1"), []);
+  });
+});
+
+describe("the canonical inline artifact (slot 2072, commit 2075)", () => {
+  test("CARRIED_INLINE, located, and named as carried by an encoding", async () => {
+    const r = await verifyFuse({ proof: liveProof, bytes: liveBytes });
+    assert.equal(r.category, "CARRIED_INLINE");
+    assert.equal(r.proof.valid, true);
+    assert.equal(r.reason, null);
+    assert.deepEqual(r.carriedBy, { kind: "encoding", id: ENCODING_BASE64URL });
+    assert.equal(r.placement, null, "an inline artifact has no placement: there is no recipe");
+    assert.equal(r.originDigestB64, null, "and no original");
+    assert.equal(r.offsets.length, 1);
+    // The bytes at the reported offset really are the commitment.
+    const at = Buffer.from(liveBytes.slice(r.offsets[0]!, r.offsets[0]! + 43)).toString("utf8");
+    assert.equal(at, r.slotCommitmentB64!.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""));
+  });
+
+  test("the span is the real one, and the statements name it", async () => {
+    const r = await verifyFuse({ proof: liveProof, bytes: liveBytes });
+    assert.equal(r.span?.slotCounter, "2072");
+    assert.equal(r.span?.commitCounter, "2075");
+    assert.match(r.statements[0] ?? "", /slot at position 2072/);
+    assert.match(r.statements[1] ?? "", /committed at position 2075/);
+  });
+
+  test("the limit rides with the claim and is carried by nothing else", async () => {
+    const r = await verifyFuse({ proof: liveProof, bytes: liveBytes });
+    assert.equal(r.limits.length, 1);
+    assert.match(r.limits[0] ?? "", /appended to a finished file pass the same check/);
+    const { proof, bytes } = await mint(() => utf8("no commitment in here"));
+    assert.deepEqual((await verifyFuse({ proof, bytes })).limits, [], "a result that establishes nothing carries no limits");
+  });
+
+  test("one edited byte is refused on the proof, not on the search", async () => {
+    const edited = new Uint8Array(liveBytes);
+    edited[edited.length - 2] = edited[edited.length - 2]! ^ 0x01;
+    const r = await verifyFuse({ proof: liveProof, bytes: edited });
+    assert.equal(r.category, "NO_MATCH", "the bytes are neither the artifact nor a declared original");
+  });
+
+  test("a measurement outside the pinned list is refused", async () => {
+    const r = await verifyFuse({ proof: liveProof, bytes: liveBytes, trustAnchors: { allowedMeasurements: ["0".repeat(96)] } });
+    assert.equal(r.category, "INVALID_UNDERLYING_PROOF");
+  });
+});
+
+describe("the other inline outcomes", () => {
+  test("every occurrence is counted and the first is the one the statement names", async () => {
+    const { proof, bytes } = await mint((c) => utf8(`${c}\nmiddle\n${c}\n`));
+    const r = await verifyFuse({ proof, bytes });
+    assert.equal(r.category, "CARRIED_INLINE");
+    assert.deepEqual(r.offsets.length, 2);
+    assert.equal(r.offsets[0], 0);
+    assert.match(r.statements[1] ?? "", /byte 0/);
+  });
+
+  test("COMMITMENT_ABSENT: the proof is valid, the bytes simply do not carry it", async () => {
+    const { proof, bytes } = await mint(() => utf8("nothing of the sort in here\n"));
+    const r = await verifyFuse({ proof, bytes });
+    assert.equal(r.category, "COMMITMENT_ABSENT");
+    assert.equal(r.proof.valid, true);
+    assert.deepEqual(r.offsets, []);
+    assert.deepEqual(r.statements, []);
+  });
+
+  test("an inline marker that declares an origin is refused: there is no original to name", async () => {
+    const { proof, bytes } = await mint((c) => utf8(`token ${c}\n`), { message: b64(new Uint8Array(32).fill(9)) });
+    const r = await verifyFuse({ proof, bytes });
+    assert.equal(r.category, "INVALID_ORIGIN_ATTRIBUTION");
+    assert.match(r.reason ?? "", /has no original/);
+  });
+
+  test("an unregistered title is UNDETERMINED_PLACEMENT, neither a pass nor a failure", async () => {
+    const { proof, bytes } = await mint((c) => utf8(`token ${c}\n`), { title: "hex/1" });
+    const r = await verifyFuse({ proof, bytes });
+    assert.equal(r.category, "UNDETERMINED_PLACEMENT");
+  });
+
+  test("a commitment appended to finished work passes, and the limit says so", async () => {
+    const { proof, bytes } = await mint((c) => utf8(`the work was already done\n${c}\n`));
+    const r = await verifyFuse({ proof, bytes });
+    assert.equal(r.category, "CARRIED_INLINE");
+    assert.ok((r.offsets[0] ?? 0) > 0);
+    assert.match(r.limits[0] ?? "", /producer's claim/);
+  });
+
+  test("a fused artifact still reports a placement, and carries no limits", async () => {
+    const fused = JSON.parse(readFileSync(FIX + "trailer.proof.json", "utf8")) as BitGraphProof;
+    const bytes = new Uint8Array(readFileSync(FIX + "fused-trailer.bin"));
+    const r = await verifyFuse({ proof: fused, bytes });
+    assert.equal(r.category, "FUSED_DIRECT");
+    assert.deepEqual(r.carriedBy, { kind: "placement", id: r.placement! });
+    assert.deepEqual(r.limits, []);
+    assert.deepEqual(r.offsets, []);
+  });
+});

package/src/__tests__/fuse-placement.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 import { describe, it } from "node:test";
 import * as assert from "node:assert/strict";
 import { placementForBytes, fusedNamesFor } from "../fuse.js";

package/src/__tests__/fuse-roundtrip.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * BitGraph Fuse: reconstruction round trips (spec 15.3). A placement enters

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

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * fuse() against a fake transport built from real fixture proofs (minted

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

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * fuseSet() against a fake transport whose commit answer MINTS the proof from

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

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * BitGraph Sets, phase 1: the set manifest codec, the set/1 placement,
@@ -52,6 +52,28 @@ import type {
 import { makeKey, signBody, b64, utf8 } from "./audit-fixtures.js";
 import type { ManualKey } from "./audit-fixtures.js";
 
+/* ⚠️ UPPERCASE THE WHOLE DIGEST, NOT ITS FIRST EIGHT CHARACTERS.
+ *
+ * Both call sites used to do `.replace(/"digest":"([0-9a-f]{8})/, upper)`, and
+ * that is a COIN FLIP. A manifest is sorted ascending by artifact digest, so
+ * the first digest in the text is the minimum of the set — which skews toward
+ * leading zeros and digits — and when all eight of those characters happen to
+ * be 0-9, uppercasing them changes nothing at all. The bytes stay canonical,
+ * parseSetManifest correctly accepts them, and the assertion that it should
+ * have REFUSED them fails. Measured: about 3-4% of runs, so roughly one red CI
+ * run in twenty-five, on a test that is not wrong about anything.
+ *
+ * A full 64-character hex digest with no letter in it has probability ~1e-15.
+ * And the assertion below turns the remaining impossibility into a loud
+ * failure rather than a silent no-op that passes for the wrong reason — which
+ * is what the old version did every time it did not flake.
+ */
+function withUppercasedDigest(text: string): string {
+  const upper = text.replace(/"digest":"([0-9a-f]{64})"/, (_m, h: string) => `"digest":"${h.toUpperCase()}"`);
+  assert.notEqual(upper, text, "the fixture has no lowercase hex digest to uppercase; this check would pass vacuously");
+  return upper;
+}
+
 const FIX = fileURLToPath(new URL("../../src/__tests__/fuse-fixtures/", import.meta.url));
 const bytes = (name: string) => new Uint8Array(readFileSync(FIX + name));
 const proofOf = (name: string) => JSON.parse(readFileSync(FIX + name, "utf8")) as BitGraphProof;
@@ -296,7 +318,7 @@ describe("codec: parseSetManifest", () => {
 
   test("8. digests: uppercase hex, 63- and 65-char hex, and other algorithm spellings are refused", () => {
     const text = dec(A.manifest);
-    assert.equal(parseSetManifest(enc(text.replace(/"digest":"([0-9a-f]{8})/, (_m, h: string) => `"digest":"${h.toUpperCase()}`))), null, "uppercase");
+    assert.equal(parseSetManifest(enc(withUppercasedDigest(text))), null, "uppercase");
     const o = asObject(A.manifest);
     const short = structuredClone(o); short.members[0]!.artifact.digest = short.members[0]!.artifact.digest.slice(0, 63);
     assert.equal(parseSetManifest(compact(short)), null, "63 chars");
@@ -770,7 +792,7 @@ describe("verifyFuseMember: manifest binding", () => {
     const text = dec(A.manifest);
     const bad: Array<[string, Uint8Array]> = [
       ["duplicate keys", enc(text.replace('"type":"bitgraph-fuse/1"', '"type":"bitgraph-fuse/1","type":"bitgraph-fuse/1"'))],
-      ["uppercase hex", enc(text.replace(/"digest":"([0-9a-f]{8})/, (_m, h: string) => `"digest":"${h.toUpperCase()}`))],
+      ["uppercase hex", enc(withUppercasedDigest(text))],
       ["whitespace", enc(JSON.stringify(asObject(A.manifest), null, 1))],
     ];
     for (const [label, explicit] of bad) {

package/src/__tests__/fuse-set2.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) 2024-2026 Mike Argento. Licensed under the MIT License. See LICENSE.
+// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
 
 /**
  * BitGraph Sets, set/2: a Merkle root over the rows instead of the list.

package/src/__tests__/fuse-vectors.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * BitGraph Fuse: fixed vectors (spec 15.2).

package/src/__tests__/fuse-verify.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * BitGraph Fuse: verifier paths (spec 15.4, 15.5, 15.8) on real fixture

package/src/__tests__/hello-world.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 import { describe, test } from "node:test";
 import * as assert from "node:assert/strict";

package/src/__tests__/policy-enforcement.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 // End-to-end test for the BitGraph policy enforcement pipeline.
 
 import { test, describe } from "node:test";

package/src/__tests__/proof-integrity.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * Tests for verifyProofIntegrity, the bytes-free proof integrity API in
@@ -17,6 +17,7 @@ import {
   verify,
   verifyProofIntegrity,
   resetEpochLinkState,
+  createVerificationContext,
   canonicalize,
 } from "@mikeargento/bitgraph-verify";
 import type { BitGraphProof, ProofIntegrityResult } from "@mikeargento/bitgraph-verify";
@@ -388,6 +389,40 @@ describe("verifyProofIntegrity: epochLink", () => {
     assert.match(result.reason ?? "", /different keys/);
   });
 
+  /* A rejected proof must not change what the verifier accepts afterwards.
+     Before 2026-09-20 the single-successor map was written during the epoch
+     link check, which runs BEFORE the policy check, so a proof refused for an
+     untrusted measurement still claimed its predecessor and the next honest
+     proof was reported as a fork. Verification is a function of its inputs. */
+  test("a proof rejected by policy does not consume its predecessor", async () => {
+    const rejected = await makeEpochLinkFixture({ toEpochId: "epoch-successor-a" });
+    const honest = await makeEpochLinkFixture({ toEpochId: "epoch-successor-b" });
+
+    const r1 = await verifyProofIntegrity({
+      proof: rejected.proof,
+      trustAnchors: { allowedMeasurements: ["some-other-measurement"] },
+    });
+    assert.equal(r1.valid, false);
+
+    const r2 = await verifyProofIntegrity({ proof: honest.proof });
+    assert.equal(r2.valid, true, r2.valid ? "" : r2.reason);
+  });
+
+  test("an explicit context keeps one verification's history out of another's", async () => {
+    const a = await makeEpochLinkFixture({ toEpochId: "epoch-successor-a" });
+    const b = await makeEpochLinkFixture({ toEpochId: "epoch-successor-b" });
+    const one = createVerificationContext();
+    const two = createVerificationContext();
+
+    assert.equal((await verifyProofIntegrity({ proof: a.proof, context: one })).valid, true);
+    assert.equal((await verifyProofIntegrity({ proof: b.proof, context: two })).valid, true);
+
+    // The same context still catches the fork.
+    const forked = await verifyProofIntegrity({ proof: b.proof, context: one });
+    assert.equal(forked.valid, false);
+    assert.match(forked.reason ?? "", /FORK DETECTED/);
+  });
+
   test("detects a fork: same predecessor consumed by two successor epochs", async () => {
     const first = await makeEpochLinkFixture({ toEpochId: "epoch-successor-a" });
     const second = await makeEpochLinkFixture({ toEpochId: "epoch-successor-b" });

package/src/__tests__/verifier.test.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 import { describe, test, before } from "node:test";
 import * as assert from "node:assert/strict";

package/src/constructor.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * bitgraph-core Constructor

package/src/fuse-cli.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * bitgraph-fuse: the internal harness (spec 9.2), as a command rather than a

package/src/fuse.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * fuse(builder, options): the producer interface of the bitgraph-fuse/1

package/src/host.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * bitgraph-core host abstraction

package/src/index.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * bitgraph-core — BitGraph
@@ -26,7 +26,8 @@ export type {
   WebAuthnAuthorization,
   AgencyEnvelope,
 } from "@mikeargento/bitgraph-verify";
-export { verify, resetEpochLinkState } from "@mikeargento/bitgraph-verify";
+export { verify, resetEpochLinkState, createVerificationContext } from "@mikeargento/bitgraph-verify";
+export type { VerificationContext } from "@mikeargento/bitgraph-verify";
 export type { VerifyResult } from "@mikeargento/bitgraph-verify";
 export { computeProofHash } from "@mikeargento/bitgraph-verify";
 export { canonicalize, canonicalizeToString, constantTimeEqual } from "@mikeargento/bitgraph-verify";

package/src/policy.ts

@@ -1,4 +1,4 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
+// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
 
 /**
  * bitgraph-core Policy — parse, hash, and validate markdown policy documents.