@mikeargento/bitgraph-player 0.15.0 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeargento/bitgraph-player",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Deterministic evaluation of causal rules over BitGraph proof bundles: a pure function from (rule, verified evidence) to a reproducible verdict.",
   "keywords": [
     "bitgraph",
@@ -43,8 +43,8 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mikeargento/bitgraph-audit": "^0.7.0",
-    "@mikeargento/bitgraph-verify": "^1.7.0"
+    "@mikeargento/bitgraph-audit": "^0.10.0",
+    "@mikeargento/bitgraph-verify": "^1.17.0"
   },
   "devDependencies": {
     "@noble/curves": "^2.3.0",

package/src/__tests__/base-floor-check.test.ts

@@ -0,0 +1,187 @@
+// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
+
+/**
+ * Base floors (enclave v10) in `check` and `compare`.
+ *
+ * From enclave v10 a recording signs its floor as a Base block
+ * (commit.slotFloor) instead of an Ethereum anchor. An audit that reads it
+ * reports a not-before segment bound with source "signed-floor" and chain
+ * "base", a TemporalAnalysis.signedFloors record per floor, and
+ * floorProblems. The Player reads those fields structurally (it still builds
+ * against an older audit), so these tests hand it AuditResult shapes with
+ * them, exactly as the fixtures elsewhere do. No ledger writes, no network.
+ */
+
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import type { AuditResult, ObservedProof, SegmentBound, TemporalSegment } from "@mikeargento/bitgraph-audit";
+import { buildCheckReport, renderCheckText } from "../check.js";
+import type { SignedFloorRecord } from "../check.js";
+import { compare } from "../order.js";
+import { digestFor, makeAudit, makeBound, proofHashOf } from "./fixtures.js";
+
+const BASE_BLOCK = 52271417;
+const BASE_TIME = 1791332181;
+const BASE_HASH = "0x71d926aeae9847fcc15fad2d4de8871923f56862d42db7a7463e95a838f8f9b0";
+
+function complete(audit: AuditResult, temporal: Record<string, unknown>): AuditResult {
+  return {
+    ...audit,
+    anomalies: { anomalies: [], divergences: [], boundaryEntryPoints: [] },
+    authorities: { groups: [], anomalies: [], sharedSignersAcrossEpochs: [] },
+    anchors: { anchors: [], metadataOnlyProofHashes: [], findings: [] },
+    witnesses: { outcomes: [], findings: [] },
+    attestations: {
+      records: [],
+      findings: [],
+      counts: {
+        proofsWithDeclaredMeasurement: 0, proofsWithDocument: 0, documentsValidated: 0, documentsFailed: 0,
+        pcr0Matches: 0, pcr0Mismatches: 0, userDataBound: 0, userDataUnbound: 0,
+      },
+    },
+    temporal: { ...audit.temporal, ...temporal },
+  } as unknown as AuditResult;
+}
+
+function baseBound(proofName: string, opts?: Partial<{ timeSource: "header" | "signed"; evidence: SegmentBound["evidence"] | "signed-floor"; blockNumber: number; timestamp: number }>): SegmentBound {
+  return {
+    ...makeBound({
+      kind: "not-before",
+      anchorProofHash: proofHashOf(proofName),
+      blockHash: BASE_HASH,
+      blockNumber: String(opts?.blockNumber ?? BASE_BLOCK),
+      timestamp: opts?.timestamp ?? BASE_TIME,
+      evidence: (opts?.evidence ?? "signed-floor") as SegmentBound["evidence"],
+      claim: "fixture Base floor bound",
+    }),
+    source: "signed-floor",
+    chain: "base",
+    timeSource: opts?.timeSource ?? "header",
+  } as SegmentBound;
+}
+
+function floorRecord(proofName: string, opts?: Partial<SignedFloorRecord>): SignedFloorRecord {
+  return {
+    proofHash: proofHashOf(proofName),
+    chain: "base",
+    blockNumber: BASE_BLOCK,
+    blockHash: BASE_HASH,
+    blockTimestamp: BASE_TIME,
+    header: "checked",
+    headerPath: "base-floor/floor-header.json",
+    bound: "not-before",
+    ...(opts ?? {}),
+  };
+}
+
+function segment(names: string[], lower: SegmentBound[], upper: SegmentBound[] = [], epochId = "E10"): TemporalSegment {
+  return {
+    partition: { publicKeyB64: "key-A", chainId: "bitgraph:main", epochId },
+    memberProofHashes: names.map(proofHashOf),
+    status: lower.length > 0 && upper.length > 0 ? "lower-bounded-with-following-anchor" : lower.length > 0 ? "lower-bounded" : upper.length > 0 ? "upper-bounded" : "ordered-but-unanchored",
+    lowerBounds: lower,
+    upperBounds: upper,
+  } as TemporalSegment;
+}
+
+function oneRecording(temporal: Record<string, unknown>, attribution?: Record<string, string>): AuditResult {
+  const audit = makeAudit({ proofs: [{ name: "r", digestB64: digestFor("r"), epochId: "E10", counter: "4", slotCounter: "3" }] });
+  if (attribution !== undefined) {
+    (audit.ingest.proofs[0]!.proof as unknown as Record<string, unknown>)["attribution"] = attribution;
+  }
+  return complete(audit, temporal);
+}
+
+describe("check: a recording that signs a Base floor", () => {
+  it("is bounded after its Base block, with the header checked, and no upper bound", () => {
+    const report = buildCheckReport(oneRecording({ segments: [segment(["r"], [baseBound("r")])], signedFloors: [floorRecord("r")] }));
+    const rec = report.recordings[0]!;
+    assert.equal(rec.bounds.status, "lower-bounded");
+    assert.equal(rec.bounds.notBefore?.chain, "base");
+    assert.equal(rec.bounds.notBefore?.evidence, "signed-floor");
+    assert.equal(rec.bounds.notBefore?.blockNumber, String(BASE_BLOCK));
+    assert.equal(rec.bounds.notAfter, undefined);
+    assert.match(rec.bounds.detail, /after Base block 52271417 \(its floor, header checked in this bundle\)/);
+    assert.doesNotMatch(rec.bounds.detail, /Ethereum/);
+    assert.ok(report.notChecked.some((n) => /Base floor blocks are Base's own/.test(n)));
+    assert.doesNotMatch(renderCheckText(report), /[–—]/);
+  });
+
+  it("without the header, says the block needs a Base lookup", () => {
+    const report = buildCheckReport(
+      oneRecording({ segments: [segment(["r"], [baseBound("r", { timeSource: "signed" })])], signedFloors: [floorRecord("r", { header: "not-carried" })] })
+    );
+    assert.match(report.recordings[0]!.bounds.detail, /confirming the block needs a Base lookup/);
+  });
+
+  it("compares bounds across chains by time, never by block number", () => {
+    // Ethereum block 25,000,000 is later in time than this Base block,
+    // whose NUMBER is larger: the tightest not-before is the Ethereum one.
+    const eth = makeBound({ kind: "not-before", anchorProofHash: "anchor-eth", blockNumber: "25000000", timestamp: BASE_TIME + 600 });
+    const report = buildCheckReport(oneRecording({ segments: [segment(["r"], [baseBound("r"), eth])], signedFloors: [floorRecord("r")] }));
+    const nb = report.recordings[0]!.bounds.notBefore!;
+    assert.equal(nb.chain, undefined);
+    assert.equal(nb.blockNumber, "25000000");
+  });
+
+  it("a fuse/3 recording's fused floor is the Base block it signs", () => {
+    const report = buildCheckReport(
+      oneRecording({ segments: [segment(["r"], [baseBound("r")])], signedFloors: [floorRecord("r")] }, { name: "bitgraph-fuse/3", title: "trailer/1" })
+    );
+    const fused = report.recordings[0]!.fused!;
+    assert.equal(fused.floor?.chain, "base");
+    assert.equal(fused.floor?.evidence, "signed-floor");
+    assert.equal(fused.floor?.blockNumber, String(BASE_BLOCK));
+    assert.match(fused.floorDetail, /Base block #52271417 .*the Base block this recording signs as its floor/);
+  });
+
+  it("a withheld floor bounds nothing and says why", () => {
+    const why = "the floor block is stamped after the attestation document was made";
+    const report = buildCheckReport(
+      oneRecording({ segments: [segment(["r"], [])], signedFloors: [floorRecord("r", { bound: "withheld", withheldReason: why })] }, { name: "bitgraph-fuse/3", title: "trailer/1" })
+    );
+    const rec = report.recordings[0]!;
+    assert.equal(rec.bounds.notBefore, undefined);
+    assert.match(rec.bounds.detail, /not used as a bound/);
+    assert.equal(rec.fused!.floor, null);
+    assert.match(rec.fused!.floorDetail, /not used as a bound/);
+  });
+
+  it("a floor problem (a recording that signs two floors) is a contradiction: FALSE", () => {
+    const report = buildCheckReport(
+      oneRecording({
+        segments: [segment(["r"], [])],
+        floorProblems: [{ code: "floor-ambiguous", proofHash: proofHashOf("r"), message: "the proof signs two floors" }],
+      })
+    );
+    assert.equal(report.result, "FALSE");
+    assert.ok(report.contradictions.some((c) => c.detail.startsWith("floor-ambiguous")));
+  });
+});
+
+describe("compare: a Base floor orders no epoch", () => {
+  it("an anchor's not-after in one epoch and a later Base floor in another answer unordered", () => {
+    const base = makeAudit({
+      proofs: [
+        { name: "old", digestB64: digestFor("old"), epochId: "E9", counter: "2" },
+        { name: "new", digestB64: digestFor("new"), epochId: "E10", counter: "2", publicKeyB64: "key-B" },
+      ],
+      partitions: [
+        { epochId: "E9", members: ["old"] },
+        { epochId: "E10", members: ["new"], publicKeyB64: "key-B" },
+      ],
+    });
+    const anchorUpper = makeBound({ kind: "not-after", anchorProofHash: "anchor-9", blockNumber: "25000000", timestamp: 1_700_000_000 });
+    const audit = complete(base, {
+      segments: [segment(["old"], [], [anchorUpper], "E9"), segment(["new"], [baseBound("new")], [], "E10")],
+      signedFloors: [floorRecord("new")],
+    });
+    const byName = (n: string): ObservedProof => audit.ingest.proofs.find((p) => p.proofHash === proofHashOf(n))!;
+    assert.equal(compare(byName("old"), byName("new"), audit).relation, "unordered");
+    assert.equal(compare(byName("new"), byName("old"), audit).relation, "unordered");
+    // The same shape with an anchor not-before on the new side does order them (old behaviour kept).
+    const anchorLower = makeBound({ kind: "not-before", anchorProofHash: "anchor-10", blockNumber: "25000100", timestamp: 1_700_001_200 });
+    const anchored = complete(base, { segments: [segment(["old"], [], [anchorUpper], "E9"), segment(["new"], [anchorLower], [], "E10")] });
+    assert.equal(compare(byName("old"), byName("new"), anchored).relation, "before");
+  });
+});

package/src/__tests__/check.test.ts

@@ -147,7 +147,7 @@ describe("check: real export fixture (disk)", () => {
   it("recognizes the enclave v5 measurement from PINS.md", () => {
     const enclave = report.recordings[0]!.lines.find((l) => l.name === "enclave")!;
     assert.match(enclave.detail, /enclave v5/);
-    assert.equal(KNOWN_ENCLAVE_MEASUREMENTS.length, 8);
+    assert.equal(KNOWN_ENCLAVE_MEASUREMENTS.length, 9);
   });
 
   it("serializes deterministically: no timestamps, no machine paths", async () => {

package/src/check.ts

@@ -70,6 +70,43 @@ import type { ThreeValued } from "./types.js";
 import { kleeneAll } from "./logic.js";
 import { PLAYER_VERSION } from "./verdict.js";
 
+// ---------------------------------------------------------------------------
+// Base floors (enclave v10), read structurally
+// ---------------------------------------------------------------------------
+
+/**
+ * What an audit that reads Base floors adds (bitgraph-audit after 0.9.0:
+ * TemporalAnalysis.signedFloors and floorProblems, and source / chain /
+ * timeSource on a segment bound). Read structurally, so the Player builds and
+ * behaves exactly as before against an audit without them; every field is
+ * optional and absent means an Ethereum anchor bound.
+ * TODO(release): bump the bitgraph-audit dependency to the release that
+ * carries signedFloors, then these can be the audit's own exported types.
+ */
+export interface SignedFloorRecord {
+  proofHash: string;
+  chain: "base";
+  blockNumber: number;
+  blockHash: string;
+  blockTimestamp: number;
+  header: "checked" | "not-carried";
+  headerPath?: string;
+  bound: "not-before" | "withheld";
+  withheldReason?: string;
+}
+export interface FloorProblem {
+  code: string;
+  proofHash?: string;
+  path?: string;
+  message: string;
+}
+type FloorAwareBound = SegmentBound & { source?: "signed-floor"; chain?: "base"; timeSource?: "header" | "signed" };
+
+function floorView(audit: AuditResult): { floors: SignedFloorRecord[]; problems: FloorProblem[] } {
+  const t = audit.temporal as { signedFloors?: SignedFloorRecord[]; floorProblems?: FloorProblem[] };
+  return { floors: t.signedFloors ?? [], problems: t.floorProblems ?? [] };
+}
+
 // ---------------------------------------------------------------------------
 // Declared knowledge: published enclave measurements
 // ---------------------------------------------------------------------------
@@ -119,7 +156,12 @@ export const KNOWN_ENCLAVE_MEASUREMENTS: ReadonlyArray<{ pcr0: string; label: st
   {
     pcr0: "934feb8bb6f4f7e2d2f85d902a7d5edd0981f706d9d2385638988ac096a05ea0583c3d00eef2a7947865ec66efc1fcf8",
     label: "enclave v9 (reproducible; the allocation returns the floor anchor, for bitgraph-fuse/2)",
-    period: "2026-09-30 onward",
+    period: "2026-09-30 to 2026-10-07",
+  },
+  {
+    pcr0: "5a947cc66095adcceefa9e5ece5d1416dfe08c3470df1bcaa5b2bc5267b0480e6cdc172fe077cd06b0afb07614307973",
+    label: "enclave v10 (reproducible; the floor is a Base block fixed at allocation, for bitgraph-fuse/3)",
+    period: "2026-10-08 onward",
   },
 ];
 
@@ -134,15 +176,24 @@ export interface CheckLine {
   detail: string;
 }
 
-/** A verified Ethereum bound on a recording, from a witness in the bundle. */
+/**
+ * A verified bound on a recording: an Ethereum anchor's, from a witness in
+ * the bundle, or (enclave v10) the Base block a recording signs as its floor,
+ * which is a not-before only.
+ */
 export interface CheckBound {
+  /** Absent for Ethereum (an anchor); "base" for a Base floor (commit.slotFloor). */
+  chain?: "base";
   blockNumber?: string;
   blockHash: string;
-  /** Unix seconds from the verified block header. */
+  /** Unix seconds: from the verified block header, or for a Base floor without one, the time the proof signs. */
   timestamp: number;
+  /** The anchor proof, or for a Base floor the recording that signs it. */
   anchorProofHash: string;
-  evidence: "chain-link" | "counter-order";
+  evidence: "chain-link" | "counter-order" | "signed-floor";
   weaker: boolean;
+  /** Base floors only: "header" checked in the bundle, or "signed" (confirming the block needs a Base lookup). */
+  timeSource?: "header" | "signed";
 }
 
 export interface CheckBounds {
@@ -153,18 +204,26 @@ export interface CheckBounds {
 }
 
 /**
- * The wall-clock floor of a fused artifact: the last verified anchored
- * block preceding its SLOT counter in the same epoch chain. Counter-order
- * evidence by construction (no hash path reaches a slot record), reported
- * with the same "genuine block" assumption as every other bound.
+ * The wall-clock floor of a fused artifact. Ethereum floors (enclave v9 and
+ * before): the last verified anchored block preceding its SLOT counter in
+ * the same epoch chain, counter-order evidence by construction (no hash path
+ * reaches a slot record). Base floors (enclave v10): the block the recording
+ * itself signs as commit.slotFloor, which a bitgraph-fuse/3 commitment binds
+ * ("signed-floor"). Either is reported with the same "genuine block"
+ * assumption as every other bound.
  */
 export interface CheckFloor {
+  /** Absent for Ethereum; "base" for the recording's own Base floor. */
+  chain?: "base";
   blockNumber?: string;
   blockHash: string;
-  /** Unix seconds from the verified block header. */
+  /** Unix seconds from the verified block header, or for a Base floor without one, the signed time. */
   timestamp: number;
+  /** The anchor proof, or for a Base floor the recording itself. */
   anchorProofHash: string;
-  evidence: "counter-order";
+  evidence: "counter-order" | "signed-floor";
+  /** Base floors only: "header" checked in the bundle, or "signed" (confirming the block needs a Base lookup). */
+  timeSource?: "header" | "signed";
 }
 
 /** What the bundle establishes about a recording marked fused (profile bitgraph-fuse/1, working name). */
@@ -337,6 +396,7 @@ export function buildCheckReport(audit: AuditResult, options?: CheckOptions): Ch
   const attestationByHash = new Map<string, ProofAttestationRecord>(
     audit.attestations.records.map((r) => [r.proofHash, r])
   );
+  const floorByHash = new Map<string, SignedFloorRecord>(floorView(audit).floors.map((f) => [f.proofHash, f]));
   const segmentByHash = new Map<string, TemporalSegment>();
   for (const segment of audit.temporal.segments) {
     for (const hash of segment.memberProofHashes) segmentByHash.set(hash, segment);
@@ -373,7 +433,8 @@ export function buildCheckReport(audit: AuditResult, options?: CheckOptions): Ch
           artifactPathByProof.get(proof.proofHash),
           webCrypto,
           options?.fuseEvidence,
-          anchorByHash
+          anchorByHash,
+          floorByHash.get(proof.proofHash)
         )
       );
     }
@@ -383,7 +444,7 @@ export function buildCheckReport(audit: AuditResult, options?: CheckOptions): Ch
   sortByPosition(anchors);
   const contradictions = collectContradictions(audit);
   const notes = collectNotes(audit, recordings, anchors, options?.fuseOriginHexes);
-  const notChecked = collectNotChecked(anchors.length > 0);
+  const notChecked = collectNotChecked(anchors.length > 0, floorByHash.size > 0);
 
   const allLines: ThreeValued[] = [
     ...recordings.map((r) => r.result),
@@ -437,7 +498,8 @@ function buildRecording(
   filePath: string | undefined,
   webCrypto: boolean,
   fuseEvidence?: ReadonlyMap<string, FuseVerifyResult>,
-  anchorByHash?: ReadonlyMap<string, AnchorRecord>
+  anchorByHash?: ReadonlyMap<string, AnchorRecord>,
+  signedFloor?: SignedFloorRecord
 ): CheckRecording {
   const lines: CheckLine[] = [];
   const v = proof.verification;
@@ -493,12 +555,13 @@ function buildRecording(
   // fused: the proof's signed attribution marks a fused artifact (profile
   // bitgraph-fuse/1). The commitment check runs over the fused bytes, or
   // over the original by reconstruction; its floor is the last verified
-  // anchor preceding the SLOT, not the commit.
+  // anchor preceding the SLOT, not the commit, or for a recording that signs
+  // a Base floor (enclave v10, bitgraph-fuse/3) that block itself.
   const marker = readFuseAttribution(proof.proof);
   let fused: CheckFused | undefined;
   if (marker !== null) {
-    const floor = fusedFloor(segment, anchorByHash, proof.slotCounter, proof.chainId);
-    const built = fusedLine(marker.placement, marker.originDigest !== undefined ? proof.proof.attribution?.message ?? null : null, fuseEvidence?.get(proof.proofHash), floor, proof);
+    const floor = signedFloor !== undefined ? ownBaseFloor(signedFloor) : fusedFloor(segment, anchorByHash, proof.slotCounter, proof.chainId);
+    const built = fusedLine(marker.placement, marker.originDigest !== undefined ? proof.proof.attribution?.message ?? null : null, fuseEvidence?.get(proof.proofHash), floor, proof, signedFloor);
     lines.push(built.line);
     fused = built.fused;
   }
@@ -516,7 +579,7 @@ function buildRecording(
     ...(filePath !== undefined && v?.tier === "full" ? { filePath } : {}),
     lines,
     result,
-    bounds: boundsFor(segment),
+    bounds: boundsFor(segment, signedFloor),
     ...(fused !== undefined ? { fused } : {}),
   };
 }
@@ -561,11 +624,29 @@ export function fusedFloor(
   };
 }
 
+/**
+ * The fused floor of a recording that signs a Base floor (enclave v10): the
+ * block itself, which a bitgraph-fuse/3 commitment binds. Null when the audit
+ * withheld it as a bound (the reason is in the floor detail).
+ */
+export function ownBaseFloor(floor: SignedFloorRecord): CheckFloor | null {
+  if (floor.bound !== "not-before") return null;
+  return {
+    chain: "base",
+    blockNumber: String(floor.blockNumber),
+    blockHash: floor.blockHash,
+    timestamp: floor.blockTimestamp,
+    anchorProofHash: floor.proofHash,
+    evidence: "signed-floor",
+    timeSource: floor.header === "checked" ? "header" : "signed",
+  };
+}
+
 const FLOOR_UNDETERMINED = "floor undetermined: no anchor precedes this slot in its epoch";
 
 function floorClause(floor: CheckFloor): string {
   const block = floor.blockNumber !== undefined ? `#${floor.blockNumber}` : floor.blockHash;
-  return `anchored block ${block} (${new Date(floor.timestamp * 1000).toISOString()})`;
+  return `${floor.chain === "base" ? "Base" : "anchored"} block ${block} (${new Date(floor.timestamp * 1000).toISOString()})`;
 }
 
 function fusedLine(
@@ -573,13 +654,19 @@ function fusedLine(
   originMessage: string | null,
   ev: FuseVerifyResult | undefined,
   floor: CheckFloor | null,
-  proof: ObservedProof
+  proof: ObservedProof,
+  signedFloor?: SignedFloorRecord
 ): { line: CheckLine; fused: CheckFused } {
   const slot = proof.slotCounter ?? "?";
   const where = placement !== null ? ` (placement ${placement})` : " (placement undeclared)";
-  const floorDetail = floor !== null
+  const floorDetail = floor !== null && floor.chain === "base"
+    ? `assembled after ${floorClause(floor)}, the Base block this recording signs as its floor` +
+      (floor.timeSource === "signed" ? "; no header for it is in this bundle, so confirming the block needs a Base lookup" : "")
+    : floor !== null
     ? `assembled after ${floorClause(floor)}, the last verified anchor preceding slot ${slot} in this epoch`
-    : proof.chainId !== ANCHORED_CHAIN
+    : signedFloor !== undefined
+      ? `floor undetermined: the Base floor this recording signs is not used as a bound (${signedFloor.withheldReason ?? "withheld"})`
+      : proof.chainId !== ANCHORED_CHAIN
       ? `floor undetermined: the slot is on chain "${proof.chainId}", not the anchored chain`
       : FLOOR_UNDETERMINED;
   const span = ev?.span !== undefined && ev.span !== null
@@ -713,9 +800,13 @@ function enclaveLine(attestedPcr0: string | undefined, attestationResult: ThreeV
   };
 }
 
-function boundsFor(segment: TemporalSegment | undefined): CheckBounds {
+function boundsFor(segment: TemporalSegment | undefined, signedFloor?: SignedFloorRecord): CheckBounds {
+  const withheld =
+    signedFloor !== undefined && signedFloor.bound === "withheld"
+      ? `; the Base floor it signs is not used as a bound (${signedFloor.withheldReason ?? "withheld"})`
+      : "";
   if (segment === undefined) {
-    return { status: "unanchored", detail: "no verified Ethereum anchor bounds this recording in this bundle" };
+    return { status: "unanchored", detail: `no verified Ethereum anchor bounds this recording in this bundle${withheld}` };
   }
   const lower = tightest(segment.lowerBounds, "not-before");
   const upper = tightest(segment.upperBounds, "not-after");
@@ -731,8 +822,8 @@ function boundsFor(segment: TemporalSegment | undefined): CheckBounds {
           : "unanchored";
   const detail =
     status === "unanchored"
-      ? "no verified Ethereum anchor bounds this recording in this bundle"
-      : `recorded ${boundsPhrase(status, notBefore, notAfter)}`;
+      ? `no verified Ethereum anchor bounds this recording in this bundle${withheld}`
+      : `recorded ${boundsPhrase(status, notBefore, notAfter)}${withheld}`;
   return {
     status,
     ...(notBefore !== undefined ? { notBefore } : {}),
@@ -756,11 +847,11 @@ function boundsPhrase(
   switch (status) {
     case "lower-bounded-with-following-anchor":
       return (
-        `after Ethereum block ${blockRef(notBefore as CheckBound)} (header verified in this bundle); precedes an anchor that consumed block ${blockRef(notAfter as CheckBound)} (header verified), an anchor-latency assumption rather than an upper bound on this recording` +
+        `${afterBlock(notBefore as CheckBound)}; precedes an anchor that consumed block ${blockRef(notAfter as CheckBound)} (header verified), an anchor-latency assumption rather than an upper bound on this recording` +
         weakerSuffix((notBefore as CheckBound).weaker || (notAfter as CheckBound).weaker)
       );
     case "lower-bounded":
-      return `after Ethereum block ${blockRef(notBefore as CheckBound)} (header verified in this bundle); no verified upper bound here` + weakerSuffix((notBefore as CheckBound).weaker);
+      return `${afterBlock(notBefore as CheckBound)}; no verified upper bound here` + weakerSuffix((notBefore as CheckBound).weaker);
     case "upper-bounded":
       return `with no verified lower bound in this bundle; an anchor that consumed block ${blockRef(notAfter as CheckBound)} followed (header verified), which is not an upper bound` + weakerSuffix((notAfter as CheckBound).weaker);
     default:
@@ -768,17 +859,31 @@ function boundsPhrase(
   }
 }
 
+/**
+ * "after Ethereum block N (header verified in this bundle)", or for a Base
+ * floor (enclave v10) "after Base block N" with where its time comes from.
+ */
+function afterBlock(b: CheckBound): string {
+  if (b.chain !== "base") return `after Ethereum block ${blockRef(b)} (header verified in this bundle)`;
+  return b.timeSource === "header"
+    ? `after Base block ${blockRef(b)} (its floor, header checked in this bundle)`
+    : `after Base block ${blockRef(b)} (its floor, at the time the proof signs; confirming the block needs a Base lookup)`;
+}
+
 /**
  * The tightest bound of a kind: for not-before the LARGEST block number
  * (latest verified anchor known to precede), for not-after the SMALLEST.
+ * Block numbers compare only within one chain: across Ethereum and Base
+ * (enclave v10 floors) the block times compare instead.
  * Ties resolve by preferring chain-link evidence over counter-order.
  */
-function tightest(bounds: SegmentBound[], kind: "not-before" | "not-after"): SegmentBound | undefined {
+function tightest(bounds: FloorAwareBound[], kind: "not-before" | "not-after"): FloorAwareBound | undefined {
   const ofKind = bounds.filter((b) => b.kind === kind);
   if (ofKind.length === 0) return undefined;
   const sorted = [...ofKind].sort((a, b) => {
-    const an = a.blockNumber !== undefined ? BigInt(a.blockNumber) : BigInt(a.timestamp);
-    const bn = b.blockNumber !== undefined ? BigInt(b.blockNumber) : BigInt(b.timestamp);
+    const sameChain = a.chain === b.chain;
+    const an = sameChain && a.blockNumber !== undefined ? BigInt(a.blockNumber) : BigInt(a.timestamp);
+    const bn = sameChain && b.blockNumber !== undefined ? BigInt(b.blockNumber) : BigInt(b.timestamp);
     if (an !== bn) return kind === "not-before" ? (an > bn ? -1 : 1) : an < bn ? -1 : 1;
     if (a.weaker !== b.weaker) return a.weaker ? 1 : -1;
     return 0;
@@ -786,14 +891,16 @@ function tightest(bounds: SegmentBound[], kind: "not-before" | "not-after"): Seg
   return sorted[0];
 }
 
-function toBound(b: SegmentBound): CheckBound {
+function toBound(b: FloorAwareBound): CheckBound {
   return {
+    ...(b.chain === "base" ? { chain: "base" as const } : {}),
     ...(b.blockNumber !== undefined ? { blockNumber: b.blockNumber } : {}),
     blockHash: b.blockHash,
     timestamp: b.timestamp,
     anchorProofHash: b.anchorProofHash,
     evidence: b.evidence,
     weaker: b.weaker,
+    ...(b.timeSource !== undefined ? { timeSource: b.timeSource } : {}),
   };
 }
 
@@ -801,9 +908,9 @@ function toBound(b: SegmentBound): CheckBound {
 function shortBoundsPhrase(b: CheckBounds): string {
   switch (b.status) {
     case "lower-bounded-with-following-anchor":
-      return `after Ethereum block ${blockRef(b.notBefore as CheckBound)}, then an anchor at block ${blockRef(b.notAfter as CheckBound)}`;
+      return `after ${chainWord(b.notBefore as CheckBound)} block ${blockRef(b.notBefore as CheckBound)}, then an anchor at block ${blockRef(b.notAfter as CheckBound)}`;
     case "lower-bounded":
-      return `after Ethereum block ${blockRef(b.notBefore as CheckBound)}`;
+      return `after ${chainWord(b.notBefore as CheckBound)} block ${blockRef(b.notBefore as CheckBound)}`;
     case "upper-bounded":
       return `with no lower bound in this bundle, then an anchor at block ${blockRef(b.notAfter as CheckBound)} (not an upper bound)`;
     default:
@@ -811,6 +918,10 @@ function shortBoundsPhrase(b: CheckBounds): string {
   }
 }
 
+function chainWord(b: CheckBound): string {
+  return b.chain === "base" ? "Base" : "Ethereum";
+}
+
 function blockRef(b: CheckBound): string {
   return b.blockNumber !== undefined ? b.blockNumber : b.blockHash;
 }
@@ -915,6 +1026,12 @@ function collectContradictions(audit: AuditResult): CheckLine[] {
       push(`${finding.code}: ${finding.message}`);
     }
   }
+  // A floor problem (enclave v10 floors): a recording that signs two floors,
+  // a malformed or off-schedule Base floor, a floor header that contradicts
+  // the signed floor or matches none. Evidence that contradicts itself.
+  for (const problem of floorView(audit).problems) {
+    push(`${problem.code}: ${problem.message}${problem.path !== undefined ? ` (${problem.path})` : ""}`);
+  }
   // An embedded proofHash that does not match the recomputed one: the
   // stored proof file was altered after the ledger wrote it, or is not
   // what it claims.
@@ -1000,13 +1117,18 @@ function collectNotes(audit: AuditResult, recordings: CheckRecording[], anchors:
   return notes;
 }
 
-function collectNotChecked(hasAnchors: boolean): string[] {
+function collectNotChecked(hasAnchors: boolean, hasBaseFloors = false): string[] {
   const out: string[] = [];
   if (hasAnchors) {
     out.push(
       "whether the anchored Ethereum blocks are canonical: their headers are recomputed here, but canonicality needs an Ethereum node or a block explorer"
     );
   }
+  if (hasBaseFloors) {
+    out.push(
+      "whether the Base floor blocks are Base's own: a header in the bundle is checked here against the signed block, but that the block is on Base's chain needs a Base node or a block explorer"
+    );
+  }
   out.push(
     "whether the anchors in this bundle are the ones BitGraph published: this is an offline check; the published anchors are listed at bitgraph.ing/ledger"
   );

package/src/order.ts

@@ -31,7 +31,10 @@
  *   - "anchor-bounds": strict block separation between verified segment
  *     bounds; always assumption-dependent (anchor freshness). If BOTH
  *     directions satisfy strict separation the evidence is contradictory
- *     and answers nothing.
+ *     and answers nothing. Only ANCHOR bounds take part: a Base floor
+ *     (enclave v10, a segment bound with source "signed-floor") is a
+ *     not-before for its own recording and orders nothing across epochs,
+ *     and its block numbers are Base's, never comparable to Ethereum's.
  * Epoch pairs supported by neither are concurrent-or-unordered, and the
  * honest answer is "unordered", never a coin flip.
  */
@@ -215,13 +218,21 @@ function boundsStrictlyOrdered(upper: SegmentBound, lower: SegmentBound): boolea
   return upper.timestamp < lower.timestamp;
 }
 
+/** A Base floor bound (enclave v10; audit field source "signed-floor"), read structurally. */
+function isFloorBound(b: SegmentBound): boolean {
+  return (b as { source?: string }).source !== undefined;
+}
+
 function anchorPrecedes(
   firstSegment: TemporalSegment,
   secondSegment: TemporalSegment
 ): { weaker: boolean; upper: SegmentBound; lower: SegmentBound } | undefined {
   let best: { weaker: boolean; upper: SegmentBound; lower: SegmentBound } | undefined;
   for (const upper of firstSegment.upperBounds) {
+    if (isFloorBound(upper)) continue;
     for (const lower of secondSegment.lowerBounds) {
+      // Anchor bounds only: a Base floor orders no epoch.
+      if (isFloorBound(lower)) continue;
       if (!boundsStrictlyOrdered(upper, lower)) continue;
       const weaker = upper.weaker || lower.weaker;
       if (best === undefined || (best.weaker && !weaker)) {

package/src/verdict.ts

@@ -31,7 +31,7 @@ import type { DeclaredEntry, Resolution, Rule, Verdict } from "./types.js";
  * A unit test asserts this equals package.json's version, so the
  * constant cannot drift silently across releases.
  */
-export const PLAYER_VERSION = "0.15.0";
+export const PLAYER_VERSION = "0.16.0";
 
 /** The player package's own version. */
 export function playerVersion(): string {