@mikeargento/bitgraph 1.9.0 → 1.9.2

package/src/__tests__/commit-service.integration.test.ts

@@ -1,117 +0,0 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
-
-/**
- * Integration test: HTTP commit service (mock server)
- *
- * Starts server/commit-service/dist/mock/mock-server.js, exercises the full
- * commit → verify cycle over HTTP, and confirms that tampered proofs are rejected.
- */
-
-import { describe, test, before, after } from "node:test";
-import * as assert from "node:assert/strict";
-import { spawn, type ChildProcess } from "node:child_process";
-import { createHash } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { join, dirname } from "node:path";
-import type { BitGraphProof } from "../index.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// Two levels up from dist/__tests__/ reaches the project root.
-const MOCK_SERVER_PATH = join(
-  __dirname,
-  "../../server/commit-service/dist/mock/mock-server.js"
-);
-
-const PORT = 18787;
-const BASE_URL = `http://localhost:${PORT}`;
-
-async function waitForServer(timeoutMs = 8000): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`${BASE_URL}/health`);
-      if (res.ok) return;
-    } catch {
-      // not ready yet
-    }
-    await new Promise<void>((r) => setTimeout(r, 100));
-  }
-  throw new Error(`Mock server did not become ready within ${timeoutMs}ms`);
-}
-
-function sha256B64(text: string): string {
-  return createHash("sha256").update(text, "utf8").digest("base64");
-}
-
-describe("HTTP commit service integration", () => {
-  let server: ChildProcess;
-
-  before(async () => {
-    server = spawn(process.execPath, [MOCK_SERVER_PATH], {
-      env: { ...process.env, PORT: String(PORT) },
-      stdio: "pipe",
-    });
-    await waitForServer();
-  });
-
-  after(() => {
-    server.kill();
-  });
-
-  test("happy path: commit + verify succeeds", async () => {
-    const digestB64 = sha256B64("hello bitgraph integration test");
-
-    // Commit
-    const commitRes = await fetch(`${BASE_URL}/commit`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ digests: [{ digestB64, hashAlg: "sha256" }] }),
-    });
-    assert.equal(commitRes.status, 200, "POST /commit should return 200");
-
-    const proofs = (await commitRes.json()) as BitGraphProof[];
-    assert.ok(Array.isArray(proofs) && proofs.length === 1, "expected one proof");
-
-    const proof = proofs[0]!;
-    assert.equal(proof.version, "bitgraph/1");
-    assert.equal(proof.artifact.digestB64, digestB64);
-
-    // Verify
-    const verifyRes = await fetch(`${BASE_URL}/verify`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ proof }),
-    });
-    assert.equal(verifyRes.status, 200, "POST /verify should return 200");
-
-    const result = (await verifyRes.json()) as { valid: boolean; reason?: string };
-    assert.equal(result.valid, true, `signature verification failed: ${result.reason}`);
-  });
-
-  test("tamper path: modified digest bytes are rejected", async () => {
-    const digestB64 = sha256B64("tamper test payload");
-
-    const commitRes = await fetch(`${BASE_URL}/commit`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ digests: [{ digestB64, hashAlg: "sha256" }] }),
-    });
-    assert.equal(commitRes.status, 200);
-
-    const proofs = (await commitRes.json()) as BitGraphProof[];
-    // Deep-clone and tamper the artifact digest
-    const tampered: BitGraphProof = JSON.parse(JSON.stringify(proofs[0]!)) as BitGraphProof;
-    tampered.artifact.digestB64 = sha256B64("completely different content");
-
-    const verifyRes = await fetch(`${BASE_URL}/verify`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ proof: tampered }),
-    });
-    assert.equal(verifyRes.status, 200);
-
-    const result = (await verifyRes.json()) as { valid: boolean; reason?: string };
-    assert.equal(result.valid, false, "tampered proof should fail verification");
-  });
-});

package/src/__tests__/constructor.test.ts

@@ -1,340 +0,0 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
-
-import { describe, test } from "node:test";
-import * as assert from "node:assert/strict";
-import { getPublicKeyAsync, signAsync } from "@noble/ed25519";
-import { Constructor } from "../constructor.js";
-import type { HostCapabilities } from "../host.js";
-
-// ---------------------------------------------------------------------------
-// Test helper: build a mock host backed by a real Ed25519 key pair
-// ---------------------------------------------------------------------------
-
-interface KeyMaterial {
-  privateKey: Uint8Array;
-  publicKeyBytes: Uint8Array;
-  publicKeyB64: string;
-}
-
-async function makeKeys(): Promise<KeyMaterial> {
-  const privateKey = crypto.getRandomValues(new Uint8Array(32));
-  const publicKeyBytes = await getPublicKeyAsync(privateKey);
-  const publicKeyB64 = Buffer.from(publicKeyBytes).toString("base64");
-  return { privateKey, publicKeyBytes, publicKeyB64 };
-}
-
-/** Minimal stub host — all required capabilities, no optional ones. */
-function baseHost(km: KeyMaterial): HostCapabilities {
-  return {
-    enforcementTier: "stub" as const,
-    getMeasurement: async () => "test-measurement-cafebabe",
-    getFreshNonce: async () => crypto.getRandomValues(new Uint8Array(16)),
-    sign: async (data: Uint8Array) => signAsync(data, km.privateKey),
-    getPublicKey: async () => km.publicKeyBytes,
-  };
-}
-
-/** Stub host that also exposes a monotonic counter. */
-function hostWithCounter(km: KeyMaterial): HostCapabilities {
-  let c = 0;
-  return {
-    enforcementTier: "stub" as const,
-    getMeasurement: async () => "test-measurement-cafebabe",
-    getFreshNonce: async () => crypto.getRandomValues(new Uint8Array(16)),
-    sign: async (data: Uint8Array) => signAsync(data, km.privateKey),
-    getPublicKey: async () => km.publicKeyBytes,
-    nextCounter: async () => String(++c),
-  };
-}
-
-/** Stub host that also exposes a secure clock. */
-function hostWithTime(km: KeyMaterial, timeMs: number): HostCapabilities {
-  return {
-    enforcementTier: "stub" as const,
-    getMeasurement: async () => "test-measurement-cafebabe",
-    getFreshNonce: async () => crypto.getRandomValues(new Uint8Array(16)),
-    sign: async (data: Uint8Array) => signAsync(data, km.privateKey),
-    getPublicKey: async () => km.publicKeyBytes,
-    secureTime: async () => timeMs,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Constructor.initialize
-// ---------------------------------------------------------------------------
-
-describe("Constructor.initialize", () => {
-  test("succeeds with a minimal host", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    assert.ok(ctor instanceof Constructor);
-  });
-
-  test("fails when getMeasurement() rejects", async () => {
-    const km = await makeKeys();
-    const host: HostCapabilities = {
-      ...baseHost(km),
-      getMeasurement: async () => { throw new Error("measurement unavailable"); },
-    };
-    await assert.rejects(
-      Constructor.initialize({ host }),
-      /preflight failed/,
-    );
-  });
-
-  test("fails when getPublicKey() rejects", async () => {
-    const km = await makeKeys();
-    const host: HostCapabilities = {
-      ...baseHost(km),
-      getPublicKey: async () => { throw new Error("key unavailable"); },
-    };
-    await assert.rejects(
-      Constructor.initialize({ host }),
-      /preflight failed/,
-    );
-  });
-
-  test("rejects requireCounter policy when host has no nextCounter", async () => {
-    const km = await makeKeys();
-    await assert.rejects(
-      Constructor.initialize({ host: baseHost(km), policy: { requireCounter: true } }),
-      /nextCounter/,
-    );
-  });
-
-  test("rejects requireTime policy when host has no secureTime", async () => {
-    const km = await makeKeys();
-    await assert.rejects(
-      Constructor.initialize({ host: baseHost(km), policy: { requireTime: true } }),
-      /secureTime/,
-    );
-  });
-
-  test("accepts requireCounter policy when host has nextCounter", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({
-      host: hostWithCounter(km),
-      policy: { requireCounter: true },
-    });
-    assert.ok(ctor instanceof Constructor);
-  });
-
-  test("accepts requireTime policy when host has secureTime", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({
-      host: hostWithTime(km, Date.now()),
-      policy: { requireTime: true },
-    });
-    assert.ok(ctor instanceof Constructor);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Constructor.commit
-// ---------------------------------------------------------------------------
-
-describe("Constructor.commit", () => {
-  test("returns a structurally valid BitGraphProof", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const bytes = new TextEncoder().encode("hello bitgraph");
-    const proof = await ctor.commit({ bytes });
-
-    assert.equal(proof.version, "bitgraph/1");
-    assert.equal(proof.artifact.hashAlg, "sha256");
-    assert.ok(typeof proof.artifact.digestB64 === "string" && proof.artifact.digestB64.length > 0);
-    assert.ok(typeof proof.commit.nonceB64 === "string" && proof.commit.nonceB64.length > 0);
-    assert.equal(proof.signer.publicKeyB64, km.publicKeyB64);
-    assert.ok(typeof proof.signer.signatureB64 === "string" && proof.signer.signatureB64.length > 0);
-    assert.equal(proof.environment.enforcement, "stub");
-    assert.equal(proof.environment.measurement, "test-measurement-cafebabe");
-  });
-
-  test("works with empty bytes", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const proof = await ctor.commit({ bytes: new Uint8Array(0) });
-    assert.equal(proof.version, "bitgraph/1");
-    assert.ok(proof.artifact.digestB64.length > 0);
-  });
-
-  test("works with large bytes (100 KB)", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    // crypto.getRandomValues is limited to 65536 bytes; use fill instead
-    const bytes = new Uint8Array(100_000).fill(0xab);
-    const proof = await ctor.commit({ bytes });
-    assert.equal(proof.version, "bitgraph/1");
-  });
-
-  test("includes metadata when provided (outside signature)", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const proof = await ctor.commit({
-      bytes: new Uint8Array([1, 2, 3]),
-      metadata: { source: "test-suite" },
-    });
-    assert.deepEqual(proof.metadata, { source: "test-suite" });
-  });
-
-  test("omits metadata field when not provided", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const proof = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.equal(proof.metadata, undefined);
-  });
-
-  test("includes counter when host provides nextCounter", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: hostWithCounter(km) });
-    const proof = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.ok(typeof proof.commit.counter === "string");
-    assert.equal(proof.commit.counter, "1");
-  });
-
-  test("counter increments across commits", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: hostWithCounter(km) });
-    const p1 = await ctor.commit({ bytes: new Uint8Array([1]) });
-    const p2 = await ctor.commit({ bytes: new Uint8Array([2]) });
-    assert.equal(p1.commit.counter, "1");
-    assert.equal(p2.commit.counter, "2");
-  });
-
-  test("includes time when host provides secureTime", async () => {
-    const km = await makeKeys();
-    const fixedTime = 1_700_000_000_000;
-    const ctor = await Constructor.initialize({ host: hostWithTime(km, fixedTime) });
-    const proof = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.equal(proof.commit.time, fixedTime);
-  });
-
-  test("includes prevB64 when provided", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const prevHash = Buffer.alloc(32).toString("base64");
-    const proof = await ctor.commit({
-      bytes: new Uint8Array([1]),
-      prevProofHashB64: prevHash,
-    });
-    assert.equal(proof.commit.prevB64, prevHash);
-  });
-
-  test("includes epochId when Constructor was initialized with one", async () => {
-    const km = await makeKeys();
-    const epochId = "epoch-abc-123";
-    const ctor = await Constructor.initialize({ host: baseHost(km), epochId });
-    const proof = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.equal(proof.commit.epochId, epochId);
-  });
-
-  test("omits epochId when not provided at initialization", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const proof = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.equal(proof.commit.epochId, undefined);
-  });
-
-  test("each commit has a unique nonce", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const p1 = await ctor.commit({ bytes: new Uint8Array([1]) });
-    const p2 = await ctor.commit({ bytes: new Uint8Array([1]) });
-    assert.notEqual(p1.commit.nonceB64, p2.commit.nonceB64);
-  });
-
-  test("fail-closed: throws when sign() rejects (no partial proof)", async () => {
-    const km = await makeKeys();
-    const badSignHost: HostCapabilities = {
-      enforcementTier: "stub" as const,
-      getMeasurement: async () => "meas",
-      getFreshNonce: async () => crypto.getRandomValues(new Uint8Array(16)),
-      sign: async () => { throw new Error("HSM offline"); },
-      getPublicKey: async () => km.publicKeyBytes,
-    };
-    const ctor = await Constructor.initialize({ host: badSignHost });
-    await assert.rejects(
-      ctor.commit({ bytes: new Uint8Array([1]) }),
-      /host\.sign\(\) rejected/,
-    );
-  });
-
-  test("throws when nonce is too short", async () => {
-    const km = await makeKeys();
-    const shortNonceHost: HostCapabilities = {
-      ...baseHost(km),
-      getFreshNonce: async () => new Uint8Array(8), // < 16 bytes required
-    };
-    const ctor = await Constructor.initialize({ host: shortNonceHost });
-    await assert.rejects(
-      ctor.commit({ bytes: new Uint8Array([1]) }),
-      /insufficient length/,
-    );
-  });
-
-  test("two commits to same bytes produce different proofs (nonce)", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const bytes = new Uint8Array([42, 43, 44]);
-    const p1 = await ctor.commit({ bytes });
-    const p2 = await ctor.commit({ bytes });
-    assert.equal(p1.artifact.digestB64, p2.artifact.digestB64); // same digest
-    assert.notEqual(p1.signer.signatureB64, p2.signer.signatureB64); // different signature
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Constructor.commitDigest
-// ---------------------------------------------------------------------------
-
-describe("Constructor.commitDigest", () => {
-  test("returns a valid proof given a correct 32-byte base64 digest", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    // SHA-256 of empty bytes
-    const digest = Buffer.alloc(32, 0xab).toString("base64");
-    const proof = await ctor.commitDigest({ digestB64: digest });
-    assert.equal(proof.version, "bitgraph/1");
-    assert.equal(proof.artifact.digestB64, digest);
-  });
-
-  test("throws for invalid base64", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    await assert.rejects(
-      ctor.commitDigest({ digestB64: "not-valid-base64!!!" }),
-      /base64/i,
-    );
-  });
-
-  test("throws when digest decodes to != 32 bytes", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    // 16 bytes, valid base64, but not 32 bytes
-    const shortDigest = Buffer.alloc(16).toString("base64");
-    await assert.rejects(
-      ctor.commitDigest({ digestB64: shortDigest }),
-      /32/,
-    );
-  });
-
-  test("throws for empty string digest", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    await assert.rejects(
-      ctor.commitDigest({ digestB64: "" }),
-      /non-empty|base64/i,
-    );
-  });
-
-  test("includes metadata when provided", async () => {
-    const km = await makeKeys();
-    const ctor = await Constructor.initialize({ host: baseHost(km) });
-    const digest = Buffer.alloc(32, 0x77).toString("base64");
-    const proof = await ctor.commitDigest({
-      digestB64: digest,
-      metadata: { mode: "digest-only" },
-    });
-    assert.deepEqual(proof.metadata, { mode: "digest-only" });
-  });
-});

package/src/__tests__/declared-proof-fixture.ts

@@ -1,65 +0,0 @@
-/**
- * The first declared recording ever made (ledger #12,010, 2026-08-18), kept
- * as a fixture because its absence is what let two verifier bugs through that
- * day (see dc26b5fd). A real WebAuthn assertion: origin https://bitgraph.ing,
- * rpIdHash = SHA-256("bitgraph.ing"), flags UP|UV|BE|BS (a synced passkey).
- * The artifact bytes are not here, so it is checked with verifyProofIntegrity.
- * Same bytes as packages/player/src/__tests__/fixtures/declared-12010/proof.json.
- */
-export const DECLARED_12010 = {
-  "version": "bitgraph/1",
-  "artifact": {
-    "hashAlg": "sha256",
-    "digestB64": "szEkIOHMuIaOXlqVG9uqKvaKtmnYmklfzOjEldzFP2E="
-  },
-  "commit": {
-    "nonceB64": "05pT2TUMA2mJ0iBsQPkOaKFIUa0i4Ta6wdNkqS3jef4=",
-    "counter": "12010",
-    "slotCounter": "12009",
-    "slotHashB64": "VbOoREc4tcmNwFFYmtfenUZ04LNkjP02wQN2okIi81Y=",
-    "epochId": "plJ+9/nhhVEvDE4X4rCjJI+zys0fIov3XT114+mQIpk=",
-    "prevB64": "3TzjHBZWqTMte6FE0BZ0SM7hrcRhFv29Sl4NMf/ZvBs=",
-    "chainId": "bitgraph:main"
-  },
-  "signer": {
-    "publicKeyB64": "tmp21VjPay+EhaMwmrFLfdjZo2KIjjT7VDqjmm27wHI=",
-    "signatureB64": "96dTfH4EYq1pRvS7zAhVZuiCLsfrlur0QkA4dfkRQZtbkQ8dgebEQn85TOdvvPtk2YYh9pP0k46HWrZuOOYlBg=="
-  },
-  "environment": {
-    "enforcement": "measured-tee",
-    "measurement": "6483cedffed74680ffb287507744a398b288c3fb943eb3f2e4fe889f8b60b3d575ad8942350360b69a1bd7bf713df27f",
-    "attestation": {
-      "format": "aws-nitro",
-      "reportB64": "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"
-    }
-  },
-  "slotAllocation": {
-    "version": "bitgraph/slot/1",
-    "nonceB64": "05pT2TUMA2mJ0iBsQPkOaKFIUa0i4Ta6wdNkqS3jef4=",
-    "counter": "12009",
-    "epochId": "plJ+9/nhhVEvDE4X4rCjJI+zys0fIov3XT114+mQIpk=",
-    "publicKeyB64": "tmp21VjPay+EhaMwmrFLfdjZo2KIjjT7VDqjmm27wHI=",
-    "chainId": "bitgraph:main",
-    "signatureB64": "LlqN1udFVXP9IFxsjwdF6//NMJZbm/IvBmlzDWJ7sfDAqCHD9fSH24w5AM4thFtf0YxMT/n5FedunYYwUQRgCA=="
-  },
-  "agency": {
-    "actor": {
-      "keyId": "ee0c65174625e065c18e732a226b649a138625ba49c3d7dde026957082035cde",
-      "publicKeyB64": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVXEkwZppHxU13Ew9Ap+BQnxQcNXuMvH6KPepQe3t8t1Jh2/aEguB0Ttrzxw9WGxmB8a3AdVVv+ybchgrL8XIRg==",
-      "algorithm": "ES256",
-      "provider": "passkey"
-    },
-    "authorization": {
-      "purpose": "bitgraph/commit-authorize/v1",
-      "format": "webauthn",
-      "actorKeyId": "ee0c65174625e065c18e732a226b649a138625ba49c3d7dde026957082035cde",
-      "artifactHash": "szEkIOHMuIaOXlqVG9uqKvaKtmnYmklfzOjEldzFP2E=",
-      "challenge": "WzE2FoHLFBQhiwQCpdR8xXA0g1FfOcRCcTEG+1iOJa4=",
-      "timestamp": 1787086799013,
-      "authenticatorDataB64": "Gv0914qYXymsoynDxplniUKsvF16m3HSkeyxwvtTjnsdAAAAAA==",
-      "clientDataJSON": "{\"type\":\"webauthn.get\",\"challenge\":\"WzE2FoHLFBQhiwQCpdR8xXA0g1FfOcRCcTEG-1iOJa4\",\"origin\":\"https://bitgraph.ing\",\"crossOrigin\":false}",
-      "signatureB64": "MEUCIQDBAxBn+pAZcq9YTCVnGcoV6TX+dC1sR1R/0ufz5GSf8gIgMrlaLEPP8f4uFLfTXHT0EA+m85x1LcQNDYqf3557Ktk="
-    }
-  },
-  "proofHash": "gpbq9mzjkjy9xz7wZAsV+eLk1kwTeOtHogysF5rYS2w="
-} as const;

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

@@ -1,32 +0,0 @@
-// Copyright (c) Mike Argento. All rights reserved. See LICENSE.
-import { describe, it } from "node:test";
-import * as assert from "node:assert/strict";
-import { placementForBytes, fusedNamesFor } from "../fuse.js";
-
-const bytes = (...b: number[]) => new Uint8Array([...b, ...new Array(24).fill(0)]);
-
-describe("placementForBytes: decided from the bytes, never the name", () => {
-  it("formats that ignore trailing data take trailer/1", () => {
-    assert.equal(placementForBytes(bytes(0xff, 0xd8, 0xff, 0xe0)), "trailer/1", "JPEG");
-    assert.equal(placementForBytes(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a)), "trailer/1", "PNG");
-    assert.equal(placementForBytes(bytes(0x47, 0x49, 0x46, 0x38, 0x39, 0x61)), "trailer/1", "GIF");
-    assert.equal(placementForBytes(bytes(0x49, 0x49, 0x2a, 0x00)), "trailer/1", "TIFF, DNG, CR2");
-    assert.equal(placementForBytes(bytes(0x4d, 0x4d, 0x00, 0x2a)), "trailer/1", "TIFF big-endian, NEF");
-    assert.equal(placementForBytes(bytes(0x42, 0x4d)), "trailer/1", "BMP");
-    assert.equal(placementForBytes(bytes(0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0, 0x57, 0x45, 0x42, 0x50)), "trailer/1", "RIFF WebP");
-  });
-  it("everything else takes container/2", () => {
-    assert.equal(placementForBytes(new TextEncoder().encode("%PDF-1.7\n")), "container/2", "PDF");
-    assert.equal(placementForBytes(bytes(0x50, 0x4b, 0x03, 0x04)), "container/2", "ZIP, Office, EPUB");
-    assert.equal(placementForBytes(bytes(0, 0, 0, 0x18, 0x66, 0x74, 0x79, 0x70)), "container/2", "ISO base media");
-    assert.equal(placementForBytes(bytes(0x1a, 0x45, 0xdf, 0xa3)), "container/2", "Matroska");
-    assert.equal(placementForBytes(bytes(0x49, 0x44, 0x33)), "container/2", "MP3");
-    assert.equal(placementForBytes(new TextEncoder().encode("# markdown\n")), "container/2", "text");
-    assert.equal(placementForBytes(new Uint8Array(0)), "container/2", "empty");
-  });
-  it("names keep the extension for trailers and use .tar for containers", () => {
-    assert.deepEqual(fusedNamesFor("IMG_0001.jpg", "trailer/1"), { fusedName: "IMG_0001.fused.jpg", frameName: "IMG_0001.jpg.bitgraph-fuse.json" });
-    assert.deepEqual(fusedNamesFor("contract.pdf", "container/2"), { fusedName: "contract.fused.tar", frameName: "contract.pdf.bitgraph-fuse.json" });
-    assert.deepEqual(fusedNamesFor("README", "container/2"), { fusedName: "README.fused.tar", frameName: "README.bitgraph-fuse.json" });
-  });
-});