chainlesschain 0.166.91 → 0.166.92

package/src/lib/evolution/evolution-eval-gate.js

@@ -6563,6 +6563,125 @@ export class EvolutionEvalReceiptVerifier {
     }
     return receiptSnapshot;
   }
+
+  #captureReceiptValidityWindows(input) {
+    if (
+      !input ||
+      isProxy(input) ||
+      !Array.isArray(input) ||
+      Object.getPrototypeOf(input) !== Array.prototype ||
+      input.length > 64 ||
+      Reflect.ownKeys(input).length !== input.length + 1
+    ) {
+      throw evalError(
+        EVOLUTION_EVAL_INVALID_CODE,
+        "receipt freshness set must contain at most 64 dense own receipts",
+      );
+    }
+    const windows = Array.from({ length: input.length }, (_, index) => {
+      const field = Object.getOwnPropertyDescriptor(input, String(index));
+      const receipt = field?.value;
+      if (
+        !field?.enumerable ||
+        !("value" in field) ||
+        !receipt ||
+        typeof receipt !== "object" ||
+        isProxy(receipt) ||
+        ![Object.prototype, null].includes(Object.getPrototypeOf(receipt))
+      ) {
+        throw evalError(
+          EVOLUTION_EVAL_INVALID_CODE,
+          "receipt validity windows require own data records",
+        );
+      }
+      const captured = {};
+      for (const key of ["issuedAt", "expiresAt"]) {
+        const timestamp = Object.getOwnPropertyDescriptor(receipt, key);
+        if (
+          !timestamp?.enumerable ||
+          !("value" in timestamp) ||
+          typeof timestamp.value !== "string"
+        )
+          throw evalError(
+            EVOLUTION_EVAL_INVALID_CODE,
+            "receipt validity timestamps require own strings",
+          );
+        captured[key] = normalizeTimestamp(timestamp.value, `receipt.${key}`);
+      }
+      // Only temporal fields are needed. Independent signed documents never
+      // become a larger aggregate canonical document just for a clock check.
+      const { issuedAt, expiresAt } = captured;
+      return {
+        issuedAt,
+        expiresAt,
+        issuedMs: new Date(issuedAt).getTime(),
+        expiresMs: new Date(expiresAt).getTime(),
+      };
+    });
+    return windows;
+  }
+
+  #assertReceiptValidityWindows(windows) {
+    // Read the captured trusted clock once, after all bounded synchronous work.
+    // Repeated asynchronous verification cannot establish a set-wide instant.
+    const checked = readClock(this.#clock);
+    if (
+      windows.some(
+        ({ issuedMs, expiresMs }) =>
+          expiresMs <= issuedMs ||
+          expiresMs - issuedMs > this.#maximumReceiptTtlMs ||
+          issuedMs > checked.milliseconds + this.#maximumClockSkewMs ||
+          expiresMs <= checked.milliseconds,
+      )
+    ) {
+      throw evalError(
+        EVOLUTION_EVAL_AUTHORITY_FAILED_CODE,
+        "evaluation receipt set is stale or has an invalid validity window",
+      );
+    }
+    return Object.freeze({
+      checkedAt: checked.timestamp,
+      earliestExpiresAt: windows.length
+        ? new Date(
+            Math.min(...windows.map((window) => window.expiresMs)),
+          ).toISOString()
+        : null,
+      signatureAuthenticated: false,
+    });
+  }
+
+  /** Temporal check only: signature and run-context verification remain separate. */
+  assertReceiptSetFreshness(input) {
+    return this.#assertReceiptValidityWindows(
+      this.#captureReceiptValidityWindows(input),
+    );
+  }
+
+  assertReceiptChunkSetFreshness(input) {
+    if (
+      !input ||
+      isProxy(input) ||
+      !Array.isArray(input) ||
+      Object.getPrototypeOf(input) !== Array.prototype ||
+      input.length > 128 ||
+      Reflect.ownKeys(input).length !== input.length + 1
+    )
+      throw evalError(
+        EVOLUTION_EVAL_INVALID_CODE,
+        "receipt validity chunks require at most 128 dense own lists",
+      );
+    const windows = [];
+    for (let index = 0; index < input.length; index++) {
+      const field = Object.getOwnPropertyDescriptor(input, String(index));
+      if (!field?.enumerable || !("value" in field))
+        throw evalError(
+          EVOLUTION_EVAL_INVALID_CODE,
+          "receipt validity chunks cannot use accessors or holes",
+        );
+      windows.push(...this.#captureReceiptValidityWindows(field.value));
+    }
+    return this.#assertReceiptValidityWindows(windows);
+  }
 }
 
 // The exported classes are composition roots. Freezing their prototypes keeps
@@ -6636,6 +6755,33 @@ export async function verifyEvolutionEvalReceipt(verifier, value, expected) {
   );
 }
 
+/** Use the genuine verifier's captured clock without exposing a callable clock port. */
+export function assertEvolutionEvalReceiptSetFreshness(verifier, receipts) {
+  if (!RECEIPT_VERIFIER_INSTANCES.has(verifier)) {
+    throw evalError(
+      EVOLUTION_EVAL_INVALID_CODE,
+      "receipt set freshness requires a trusted read-only verifier instance",
+    );
+  }
+  return EvolutionEvalReceiptVerifier.prototype.assertReceiptSetFreshness.call(
+    verifier,
+    receipts,
+  );
+}
+
+/** Independently bounded cohort windows share one final captured-clock reading. */
+export function assertEvolutionEvalReceiptChunkSetFreshness(verifier, chunks) {
+  if (!RECEIPT_VERIFIER_INSTANCES.has(verifier))
+    throw evalError(
+      EVOLUTION_EVAL_INVALID_CODE,
+      "receipt chunk freshness requires a trusted read-only verifier instance",
+    );
+  return EvolutionEvalReceiptVerifier.prototype.assertReceiptChunkSetFreshness.call(
+    verifier,
+    chunks,
+  );
+}
+
 const RESULT_ROW_KEYS = new Set([
   "taskDigest",
   "seed",

package/src/lib/evolution/evolution-eval-launch-admission.js

@@ -10,8 +10,12 @@ import {
 import {
   EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA,
   EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA,
-  EvolutionLedger,
 } from "./evolution-ledger.js";
+import {
+  captureEvolutionEvalLedger,
+  readEvolutionEvalLedger,
+} from "./evolution-eval-ledger-capture.js";
+import { captureEvolutionEvalReadonlyAudit } from "./evolution-eval-readonly-audit.js";
 
 export const EVOLUTION_EVAL_LAUNCH_ADMISSION_SCHEMA =
   "chainlesschain.evolution-eval-launch-admission/v1";
@@ -112,11 +116,13 @@ function text(value, label) {
 }
 
 function digest(value, label) {
-  if (!DIGEST.test(value ?? "")) fail(`${label} must be a sha256 digest`);
+  if (typeof value !== "string" || !DIGEST.test(value))
+    fail(`${label} must be a sha256 digest`);
   return value;
 }
 
 function timestamp(value, label) {
+  if (typeof value !== "string") fail(`${label} is invalid`);
   const parsed = Date.parse(value);
   if (
     typeof value !== "string" ||
@@ -248,16 +254,14 @@ function eventId(state) {
 }
 
 function events(state) {
-  return EvolutionLedger.prototype.read
-    .call(state.ledger)
-    .filter(
-      (event) =>
-        event.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA &&
-        event.eventId === eventId(state),
-    );
+  return readEvolutionEvalLedger(state.ledgerMethods).filter(
+    (event) =>
+      event.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA &&
+      event.eventId === eventId(state),
+  );
 }
 
-function resolveEvent(state, event) {
+function resolveEvent(state, event, capturedIdentity = null) {
   if (
     event.type !== EVOLUTION_EVAL_LAUNCH_ADMISSION_EVENT_TYPE ||
     event.tenantId !== state.descriptor.tenantId ||
@@ -270,7 +274,7 @@ function resolveEvent(state, event) {
       canonical(state.enrollment ? [state.enrollment.enrollmentRef] : [])
   )
     fail("admission ledger event is substituted");
-  const identity = EvolutionLedger.prototype.verify.call(state.ledger);
+  const identity = capturedIdentity ?? state.ledgerMethods.verify();
   const resolution = state.resolveArtifact({
     epoch: identity.epoch,
     ledgerId: identity.ledgerId,
@@ -332,13 +336,20 @@ export function createEvolutionEvalLaunchAdmissionAuthority({
   if (
     !(artifactPorts instanceof EvolutionArtifactPorts) ||
     isProxy(artifactPorts) ||
-    !(ledger instanceof EvolutionLedger) ||
     isProxy(ledger) ||
     !isEvolutionLedgerArtifactResolver(ledgerArtifactResolver)
   )
     fail(
       "admission requires real artifact ports, Ledger and a branded resolver",
     );
+  let ledgerMethods;
+  try {
+    ledgerMethods = captureEvolutionEvalLedger(ledger);
+  } catch {
+    fail(
+      "admission requires real artifact ports, Ledger and a branded resolver",
+    );
+  }
   if (typeof now !== "function" || isProxy(now) || !signer || isProxy(signer))
     fail("admission signer and clock are required");
   const sign = Object.getOwnPropertyDescriptor(signer, "sign")?.value;
@@ -357,6 +368,7 @@ export function createEvolutionEvalLaunchAdmissionAuthority({
     sign: sign.bind(signer),
     artifactPorts,
     ledger,
+    ledgerMethods,
     resolveArtifact: ledgerArtifactResolver,
     now,
     enrollment:
@@ -389,6 +401,12 @@ export function captureEvolutionEvalLaunchAdmissionBinding(authority) {
     enrollmentDigest: state.enrollment?.enrollmentDigest ?? null,
     cohortCompletenessAuthenticated: false,
     promotionAuthority: false,
+    ...(state.enrollment?.registrationKind
+      ? {
+          registrationKind: state.enrollment.registrationKind,
+          historyBinding: state.enrollment.historyBinding,
+        }
+      : {}),
   });
 }
 
@@ -402,85 +420,102 @@ function authorityState(authority) {
 export async function admitEvolutionEvalLaunch(authority, input) {
   const state = authorityState(authority);
   const captured = request(input, state, true);
-  // Capture head BEFORE the occupancy read: a concurrent append cannot escape CAS.
-  const head = EvolutionLedger.prototype.verify.call(state.ledger);
-  if (state.enrollment) state.enrollment.assertOpen(captured);
-  if (events(state).length !== 0) fail("admission slot is already occupied");
-  const core = {
-    schema: state.enrollment
-      ? EVOLUTION_EVAL_ENROLLED_LAUNCH_ADMISSION_SCHEMA
-      : EVOLUTION_EVAL_LAUNCH_ADMISSION_SCHEMA,
-    descriptorDigest: state.descriptorDigest,
-    ...captured,
-    ...(state.enrollment
-      ? {
-          enrollmentDigest: state.enrollment.enrollmentDigest,
-          descriptor: state.descriptor,
-        }
-      : {}),
-  };
-  const signature = state.sign(
-    Object.freeze({ message: message(core).toString("utf8") }),
-  );
-  const evidence = verifyEvidence(
-    {
-      ...core,
-      attestation: {
-        algorithm: "ed25519",
-        issuer: state.descriptor.authorityId,
-        keyId: state.descriptor.keyId,
-        trustPolicyDigest: state.descriptor.trustPolicyDigest,
-        value: signature,
+  let nativePrepared = false;
+  try {
+    // A native claim appends its paired budget intent before the admission CAS
+    // snapshot. Both subsequent assertOpen calls are strictly read-only.
+    if (state.enrollment?.prepare) {
+      state.enrollment.prepare(captured);
+      nativePrepared = true;
+    }
+    // Capture head BEFORE the occupancy read: a concurrent append cannot escape CAS.
+    const head = state.ledgerMethods.verify();
+    if (state.enrollment) state.enrollment.assertOpen(captured);
+    if (events(state).length !== 0) fail("admission slot is already occupied");
+    const core = {
+      schema: state.enrollment
+        ? EVOLUTION_EVAL_ENROLLED_LAUNCH_ADMISSION_SCHEMA
+        : EVOLUTION_EVAL_LAUNCH_ADMISSION_SCHEMA,
+      descriptorDigest: state.descriptorDigest,
+      ...captured,
+      ...(state.enrollment
+        ? {
+            enrollmentDigest: state.enrollment.enrollmentDigest,
+            descriptor: state.descriptor,
+          }
+        : {}),
+    };
+    const signature = state.sign(
+      Object.freeze({ message: message(core).toString("utf8") }),
+    );
+    const evidence = verifyEvidence(
+      {
+        ...core,
+        attestation: {
+          algorithm: "ed25519",
+          issuer: state.descriptor.authorityId,
+          keyId: state.descriptor.keyId,
+          trustPolicyDigest: state.descriptor.trustPolicyDigest,
+          value: signature,
+        },
       },
-    },
-    state,
-  );
-  request(captured, state, true);
-  const published = EvolutionArtifactPorts.prototype.putCanonical.call(
-    state.artifactPorts,
-    ARTIFACT_TYPE,
-    evidence,
-    {
-      audience: state.descriptor.audience,
-      purpose: state.descriptor.purpose,
-      retention: "ledger",
-    },
-  );
-  if (
-    published?.receipt?.persisted !== true ||
-    published.receipt.readbackVerified !== true ||
-    published.receipt.integrityVerified !== true ||
-    published.receipt.retention !== "ledger"
-  )
-    fail("admission artifact persistence failed");
-  request(captured, state, true);
-  if (state.enrollment) state.enrollment.assertOpen(captured);
-  const receipt = EvolutionLedger.prototype.appendDomainEvent.call(
-    state.ledger,
-    {
-      type: EVOLUTION_EVAL_LAUNCH_ADMISSION_EVENT_TYPE,
-      eventId: eventId(state),
-      tenantId: state.descriptor.tenantId,
-      artifactTenantId: state.descriptor.artifactTenantId,
-      correlationId: state.descriptor.streamId,
-      decision: "accepted",
-      skillName: "evolution-eval",
-      reason: "signed attempt admission; Actor execution is unproven",
-      sourceRefs: state.enrollment ? [state.enrollment.enrollmentRef] : [],
-      subjectRef: published.ref,
-      timestamp: captured.admittedAt,
-    },
-    { expectedHeadDigest: head.headDigest, expectedSequence: head.sequence },
-  );
-  if (receipt?.authenticated !== true || receipt.durable !== true)
-    fail("admission ledger append failed");
-  const matches = events(state);
-  if (matches.length !== 1) fail("admission slot is absent or ambiguous");
-  const result = resolveEvent(state, matches[0]);
-  if (canonical(result.evidence) !== canonical(evidence))
-    fail("admission readback differs from signed bytes");
-  request(captured, state, true);
-  return result;
+      state,
+    );
+    request(captured, state, true);
+    const published = EvolutionArtifactPorts.prototype.putCanonical.call(
+      state.artifactPorts,
+      ARTIFACT_TYPE,
+      evidence,
+      {
+        audience: state.descriptor.audience,
+        purpose: state.descriptor.purpose,
+        retention: "ledger",
+      },
+    );
+    if (
+      published?.receipt?.persisted !== true ||
+      published.receipt.readbackVerified !== true ||
+      published.receipt.integrityVerified !== true ||
+      published.receipt.retention !== "ledger"
+    )
+      fail("admission artifact persistence failed");
+    request(captured, state, true);
+    if (state.enrollment) state.enrollment.assertOpen(captured);
+    const receipt = state.ledgerMethods.appendDomainEvent(
+      {
+        type: EVOLUTION_EVAL_LAUNCH_ADMISSION_EVENT_TYPE,
+        eventId: eventId(state),
+        tenantId: state.descriptor.tenantId,
+        artifactTenantId: state.descriptor.artifactTenantId,
+        correlationId: state.descriptor.streamId,
+        decision: "accepted",
+        skillName: "evolution-eval",
+        reason: "signed attempt admission; Actor execution is unproven",
+        sourceRefs: state.enrollment ? [state.enrollment.enrollmentRef] : [],
+        subjectRef: published.ref,
+        timestamp: captured.admittedAt,
+      },
+      { expectedHeadDigest: head.headDigest, expectedSequence: head.sequence },
+    );
+    if (receipt?.authenticated !== true || receipt.durable !== true)
+      fail("admission ledger append failed");
+    const matches = events(state);
+    if (matches.length !== 1) fail("admission slot is absent or ambiguous");
+    const result = resolveEvent(state, matches[0]);
+    if (canonical(result.evidence) !== canonical(evidence))
+      fail("admission readback differs from signed bytes");
+    request(captured, state, true);
+    return result;
+  } catch (error) {
+    if (nativePrepared && state.enrollment?.recordFailure) {
+      try {
+        state.enrollment.recordFailure();
+      } catch {
+        /* Preserve the original failure; durable intent and ceilings remain. */
+      }
+    }
+    throw error;
+  }
 }
 
 /** Durable audit/recovery may outlive the execution deadline; it grants no execution permit. */
@@ -503,3 +538,46 @@ export async function resolveEvolutionEvalLaunch(authority, input) {
     fail("admission lookup differs from the recorded attempt");
   return result;
 }
+
+/**
+ * Verify an admission within a genuine immutable journal view. The caller must
+ * complete the whole audit with assertUnchanged before publishing its result.
+ * This does not call admission preparation or grant an execution permit.
+ */
+export async function resolveEvolutionEvalLaunchFromReadonlyAudit(
+  authority,
+  input,
+  audit,
+) {
+  const state = authorityState(authority);
+  const captured = captureEvolutionEvalReadonlyAudit(audit, state.ledger);
+  const expected = record(
+    input,
+    ["runId", "runNonce", "requestDigest"],
+    "admission lookup",
+  );
+  text(expected.runId, "runId");
+  text(expected.runNonce, "runNonce");
+  digest(expected.requestDigest, "requestDigest");
+  const matches = captured
+    .eventsById(eventId(state))
+    .filter((event) => event.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA);
+  if (matches.length !== 1) fail("admission slot is absent or ambiguous");
+  const result = resolveEvent(state, matches[0], captured.identity);
+  if (
+    Object.keys(expected).some((key) => result.evidence[key] !== expected[key])
+  )
+    fail("admission lookup differs from the recorded attempt");
+  // An artifact resolver can reenter another audit operation. Respect any
+  // invalidation already detected there without another full journal scan.
+  captureEvolutionEvalReadonlyAudit(audit, state.ledger);
+  return frozen({
+    ...result,
+    schema:
+      "chainlesschain.evolution-eval-launch-admission-audit-resolution/v1",
+    auditHead: captured.identity,
+    historicalSnapshotOnly: true,
+    requiresFinalAuditHeadCheck: true,
+    readyForExecution: false,
+  });
+}

package/src/lib/evolution/evolution-eval-ledger-capture.js

@@ -0,0 +1,50 @@
+/** Capture the actual journal; never follow a v2 journal back to its source Ledger. */
+import { isProxy } from "node:util/types";
+import {
+  EvolutionLedger,
+  EVOLUTION_LEDGER_MAX_EVENTS,
+} from "./evolution-ledger.js";
+import { isEvolutionLedgerV2Journal } from "./evolution-ledger-v2-journal.js";
+
+export function captureEvolutionEvalLedger(ledger) {
+  if (!ledger || isProxy(ledger))
+    throw new TypeError("Eval requires a genuine Ledger journal");
+  const methods = {};
+  for (const name of ["read", "verify", "appendDomainEvent"]) {
+    if (ledger instanceof EvolutionLedger)
+      methods[name] = (...args) =>
+        Reflect.apply(EvolutionLedger.prototype[name], ledger, args);
+    else if (isEvolutionLedgerV2Journal(ledger)) {
+      const method = Object.getOwnPropertyDescriptor(ledger, name)?.value;
+      if (typeof method !== "function" || isProxy(method))
+        throw new TypeError("Eval v2 journal method is missing");
+      methods[name] = (...args) => Reflect.apply(method, ledger, args);
+    } else throw new TypeError("Eval requires a genuine Ledger journal");
+  }
+  return Object.freeze(methods);
+}
+
+/** Complete, contiguous census with bookends; defaults must not truncate at 10,000. */
+export function readEvolutionEvalLedger(methods) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const before = methods.verify();
+    const events = methods.read({
+      afterSequence: 0,
+      limit: EVOLUTION_LEDGER_MAX_EVENTS,
+    });
+    const after = methods.verify();
+    if (
+      !["ledgerId", "identityDigest", "epoch", "headDigest", "sequence"].every(
+        (name) => before[name] === after[name],
+      )
+    )
+      continue;
+    if (
+      events.length !== after.sequence ||
+      events.some((event, index) => event.sequence !== index + 1)
+    )
+      throw new Error("Eval requires complete contiguous Ledger coverage");
+    return events;
+  }
+  throw new Error("Ledger changed during Eval census; retry audit");
+}

package/src/lib/evolution/evolution-eval-readonly-audit.js

@@ -0,0 +1,106 @@
+/** One immutable journal view; authentication finishes at its final head check. */
+import {
+  captureEvolutionEvalLedger,
+  readEvolutionEvalLedger,
+} from "./evolution-eval-ledger-capture.js";
+
+const AUDITS = new WeakMap();
+const HEAD_FIELDS = [
+  "ledgerId",
+  "identityDigest",
+  "epoch",
+  "sequence",
+  "headDigest",
+];
+const EMPTY_EVENTS = Object.freeze([]);
+
+function fail(message) {
+  const error = new Error(message);
+  error.code = "CC_EVOLUTION_EVAL_READONLY_AUDIT_FAILED";
+  throw error;
+}
+
+function readHead(methods) {
+  const current = methods.verify();
+  return Object.freeze(
+    Object.fromEntries(HEAD_FIELDS.map((field) => [field, current[field]])),
+  );
+}
+
+function sameHead(left, right) {
+  return HEAD_FIELDS.every((field) => left[field] === right[field]);
+}
+
+// Events come only from the genuine journal's verified read. Preserve native
+// null-prototype references and freeze each event independently; the complete
+// journal must not become one RRSI-sized canonical document.
+function freezeEvent(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freezeEvent);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+export function createEvolutionEvalReadonlyAudit(ledger) {
+  const methods = captureEvolutionEvalLedger(ledger);
+  const identity = readHead(methods);
+  const events = Object.freeze(
+    readEvolutionEvalLedger(methods).map(freezeEvent),
+  );
+  const byEventId = new Map();
+  for (const event of events) {
+    if (typeof event.eventId !== "string") continue;
+    let matches = byEventId.get(event.eventId);
+    if (!matches) byEventId.set(event.eventId, (matches = []));
+    matches.push(event);
+  }
+  for (const matches of byEventId.values()) Object.freeze(matches);
+  if (!sameHead(identity, readHead(methods)))
+    fail("Ledger changed while capturing the read-only audit");
+
+  let invalidated = false;
+  function assertActive() {
+    if (invalidated) fail("read-only audit was invalidated by a Ledger change");
+  }
+  const captured = Object.freeze({
+    identity,
+    events,
+    eventsById(id) {
+      assertActive();
+      if (typeof id !== "string") fail("audit event ID must be a string");
+      return byEventId.get(id) ?? EMPTY_EVENTS;
+    },
+    assertUnchanged() {
+      assertActive();
+      let current;
+      try {
+        current = readHead(methods);
+      } catch (error) {
+        invalidated = true;
+        throw error;
+      }
+      if (!sameHead(identity, current)) {
+        invalidated = true;
+        fail(
+          "Ledger changed during the read-only audit; retry with a new view",
+        );
+      }
+      return identity;
+    },
+  });
+  const audit = Object.freeze({
+    schema: "chainlesschain.evolution-eval-readonly-audit/v1",
+  });
+  AUDITS.set(audit, { ledger, captured, assertActive });
+  return audit;
+}
+
+/** Capture does not rescan the journal; the consumer must finish with assertUnchanged. */
+export function captureEvolutionEvalReadonlyAudit(audit, ledger) {
+  const state = AUDITS.get(audit);
+  if (!state || state.ledger !== ledger)
+    fail("a genuine read-only audit of the same Ledger journal is required");
+  state.assertActive();
+  return state.captured;
+}

package/src/lib/evolution/evolution-ledger-file-backend.js

@@ -11,6 +11,7 @@ export const EVOLUTION_LEDGER_FILE_BACKEND_SCHEMA =
   "chainlesschain.evolution-ledger-file-backend/v1";
 
 const BACKENDS = new WeakSet();
+const BACKEND_BINDINGS = new WeakMap();
 
 function requiredString(value, label) {
   if (typeof value !== "string" || value.trim() === "") {
@@ -205,6 +206,15 @@ export function createEvolutionLedgerFileBackend({
     witness,
   });
   BACKENDS.add(backend);
+  BACKEND_BINDINGS.set(
+    backend,
+    Object.freeze({
+      matchesLedger: Object.freeze((value) => value === ledger),
+      matchesArtifactResolver: Object.freeze(
+        (value) => value === artifactResolver,
+      ),
+    }),
+  );
   return backend;
 }
 
@@ -214,3 +224,13 @@ export function captureEvolutionLedgerFileBackend(value) {
   }
   return value;
 }
+
+/** Compare the original journal/resolver objects without exposing signing ports. */
+export function captureEvolutionLedgerFileBackendBinding(value) {
+  const binding = BACKEND_BINDINGS.get(value);
+  if (!binding)
+    throw new TypeError(
+      "a branded EvolutionLedger file backend binding is required",
+    );
+  return binding;
+}