@mikeargento/bitgraph-player 0.2.0 → 0.3.0

package/dist/types.d.ts

@@ -108,9 +108,19 @@ export type Claim = {
     any: Claim[];
 } | {
     not: Claim;
+}
+/**
+ * Format 2 only: a valid bitgraph-sig/1 by the named trusted key over
+ * the role's digest is present in the supplied evidence. TRUE or
+ * UNDETERMINED, never FALSE — "this key never signed these bytes" is a
+ * negative over an open world no bundle can close.
+ */
+ | {
+    signedBy: [string, string];
 };
+export type RuleFormat = "bitgraph-player/1" | "bitgraph-player/2";
 export interface Rule {
-    rule: "bitgraph-player/1";
+    rule: RuleFormat;
     id: string;
     cast: Record<string, CastEntry>;
     /** The only defined value. Absence is only ever asserted within the declared cast. */
@@ -122,6 +132,13 @@ export interface Rule {
     requires: {
         ordering: EvidenceTier;
     };
+    /**
+     * Format 2 only. Named keys the rule author trusts. The name-to-key
+     * binding is DECLARED — surfaced in the verdict, never derived. What
+     * becomes derived under format 2 is only the math: a signature by the
+     * named key material verifies over the role's digest.
+     */
+    trustedKeys?: Record<string, import("./sig.js").TrustedKey>;
     claim: Claim;
     /**
      * A label and nothing else. No field in this format is capable of
@@ -168,13 +185,14 @@ export interface DerivedStep {
 }
 /** One assertion Player took on somebody's word. */
 export interface DeclaredEntry {
-    assertion: "signedBy" | "means" | "closed-world" | "pinned-occurrence";
+    assertion: "signedBy" | "means" | "closed-world" | "pinned-occurrence" | "trusted-key";
     role?: string;
     verifiedHere: false;
     [k: string]: unknown;
 }
 export interface Verdict {
-    verdict: "bitgraph-player-verdict/1";
+    /** Tracks the rule format: a /1 rule yields a /1 verdict, byte-identical to prior releases. */
+    verdict: "bitgraph-player-verdict/1" | "bitgraph-player-verdict/2";
     result: ThreeValued;
     rule: {
         id: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/verdict.d.ts

@@ -26,7 +26,7 @@ import type { 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 declare const PLAYER_VERSION = "0.2.0";
+export declare const PLAYER_VERSION = "0.3.0";
 /** The player package's own version. */
 export declare function playerVersion(): string;
 export declare function buildVerdict(rule: Rule, ruleSha256Hex: string, resolutions: Map<string, Resolution>, evaluation: Evaluation, audit: AuditResult): Verdict;

package/dist/verdict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../src/verdict.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAiB,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,wCAAwC;AACxC,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAeD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EACpC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,WAAW,GACjB,OAAO,CA6ET;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAkBzD"}
+{"version":3,"file":"verdict.d.ts","sourceRoot":"","sources":["../src/verdict.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAiB,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC,wCAAwC;AACxC,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAeD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,EACV,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EACpC,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,WAAW,GACjB,OAAO,CA6FT;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAkBzD"}

package/dist/verdict.js

@@ -9,7 +9,7 @@ import { normalizeDigest } from "./rule.js";
  * A unit test asserts this equals package.json's version, so the
  * constant cannot drift silently across releases.
  */
-export const PLAYER_VERSION = "0.2.0";
+export const PLAYER_VERSION = "0.3.0";
 /** The player package's own version. */
 export function playerVersion() {
     return PLAYER_VERSION;
@@ -81,6 +81,21 @@ export function buildVerdict(rule, ruleSha256Hex, resolutions, evaluation, audit
             });
         }
     }
+    // Format 2: the name-to-key bindings are declared trust. The signature
+    // MATH is derived (it appears in `derived` steps); that key K IS the
+    // named party is taken on the rule author's word, exactly like a cast
+    // digest's meaning.
+    if (rule.trustedKeys !== undefined) {
+        for (const [keyName, key] of Object.entries(rule.trustedKeys)) {
+            declared.push({
+                assertion: "trusted-key",
+                verifiedHere: false,
+                keyName,
+                alg: key.alg,
+                publicKey: key.publicKey,
+            });
+        }
+    }
     declared.push({
         assertion: "closed-world",
         verifiedHere: false,
@@ -89,7 +104,7 @@ export function buildVerdict(rule, ruleSha256Hex, resolutions, evaluation, audit
         claim: "Absence is asserted only among the declared cast. Nothing in BitGraph establishes that the declared cast is complete; that completeness is the rule author's assertion.",
     });
     const verdict = {
-        verdict: "bitgraph-player-verdict/1",
+        verdict: rule.rule === "bitgraph-player/2" ? "bitgraph-player-verdict/2" : "bitgraph-player-verdict/1",
         result: evaluation.result,
         rule: { id: rule.id, sha256: ruleSha256Hex },
         cast,

package/dist/verdict.js.map

@@ -1 +1 @@
-{"version":3,"file":"verdict.js","sourceRoot":"","sources":["../src/verdict.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"verdict.js","sourceRoot":"","sources":["../src/verdict.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeargento/bitgraph-player",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Deterministic evaluation of causal rules over BitGraph proof bundles: a pure function from (rule, verified evidence) to a reproducible verdict.",
   "license": "MIT",
   "type": "module",

package/src/__tests__/sig-v2.test.ts

@@ -0,0 +1,315 @@
+// Copyright (c) 2024-2026 Mike Argento. Licensed under the MIT License. See LICENSE.
+
+/**
+ * Format 2: trustedKeys + signedBy.
+ *
+ * The invariants under test:
+ *   - signedBy is TRUE or UNDETERMINED, never FALSE, so not(signedBy)
+ *     is permanently UNDETERMINED: no open-world negative escapes.
+ *   - Signature math is derived; the name-to-key binding is declared.
+ *   - A /1 rule parses and evaluates exactly as before (verdict/1), and
+ *     /2-only syntax in a /1 rule is a parse error.
+ *   - Broken signature files are noise, never evidence and never errors.
+ *
+ * All evidence is synthetic and in-memory. No ledger writes, ever.
+ */
+
+import { strict as assert } from "node:assert";
+import { createHash, generateKeyPairSync, sign as cryptoSign } from "node:crypto";
+import { test } from "node:test";
+import { evaluate } from "../evaluate.js";
+import { playAudit, claimUsesSignatures } from "../play.js";
+import { parseRule, RuleError } from "../rule.js";
+import { parseSigFile, sigMessage } from "../sig.js";
+import { resolveCast } from "../cast.js";
+import { digestFor, makeAudit } from "./fixtures.js";
+
+// ---------------------------------------------------------------------------
+// Key + signature helpers (in-memory, per-run keys; verification is the
+// deterministic part under test, not key generation)
+// ---------------------------------------------------------------------------
+
+function ed25519Pair(): { publicKeyB64: string; privateKey: import("node:crypto").KeyObject } {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const spki = publicKey.export({ format: "der", type: "spki" }) as Buffer;
+  // Raw key = last 32 bytes of the SPKI encoding.
+  return { publicKeyB64: spki.subarray(spki.length - 32).toString("base64"), privateKey };
+}
+
+function es256Pair(): { publicKeyB64: string; privateKey: import("node:crypto").KeyObject } {
+  const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "P-256" });
+  const spki = publicKey.export({ format: "der", type: "spki" }) as Buffer;
+  return { publicKeyB64: spki.toString("base64"), privateKey };
+}
+
+function hexOfB64(digestB64: string): string {
+  return Buffer.from(digestB64, "base64").toString("hex");
+}
+
+function makeSigBytes(
+  alg: "ed25519" | "es256",
+  publicKeyB64: string,
+  privateKey: import("node:crypto").KeyObject,
+  overHex: string
+): Uint8Array {
+  const message = sigMessage(overHex);
+  const signature =
+    alg === "ed25519"
+      ? cryptoSign(null, message, privateKey)
+      : cryptoSign("sha256", message, privateKey);
+  return Buffer.from(
+    JSON.stringify({
+      sig: "bitgraph-sig/1",
+      over: `sha256:${overHex}`,
+      alg,
+      publicKey: publicKeyB64,
+      signature: signature.toString("base64"),
+    })
+  );
+}
+
+function evidenceOf(...items: Uint8Array[]): Map<string, Uint8Array> {
+  const map = new Map<string, Uint8Array>();
+  for (const bytes of items) {
+    map.set(createHash("sha256").update(bytes).digest("hex"), bytes);
+  }
+  return map;
+}
+
+const WORK = digestFor("work");
+
+function v2Rule(publicKeyB64: string, alg: "ed25519" | "es256", claim: unknown): string {
+  return JSON.stringify({
+    rule: "bitgraph-player/2",
+    id: "test-v2",
+    cast: { work: { digest: WORK } },
+    world: "closed",
+    requires: { ordering: "assumption-dependent" },
+    trustedKeys: { mike: { alg, publicKey: publicKeyB64 } },
+    claim,
+  });
+}
+
+function auditWithWork() {
+  return makeAudit({
+    proofs: [{ name: "w", digestB64: WORK, epochId: "e1", counter: "1" }],
+    partitions: [{ epochId: "e1", members: ["w"] }],
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+
+test("signedBy in a /1 rule is a parse error", () => {
+  const text = JSON.stringify({
+    rule: "bitgraph-player/1",
+    id: "r",
+    cast: { work: { digest: WORK } },
+    world: "closed",
+    requires: { ordering: "hash-linked" },
+    claim: { signedBy: ["work", "mike"] },
+  });
+  assert.throws(() => parseRule(text), RuleError);
+});
+
+test("trustedKeys in a /1 rule is a parse error", () => {
+  const text = JSON.stringify({
+    rule: "bitgraph-player/1",
+    id: "r",
+    cast: { work: { digest: WORK } },
+    world: "closed",
+    requires: { ordering: "hash-linked" },
+    trustedKeys: { mike: { alg: "ed25519", publicKey: "A".repeat(43) + "=" } },
+    claim: { exists: "work" },
+  });
+  assert.throws(() => parseRule(text), RuleError);
+});
+
+test("signedBy referencing an undeclared trusted key is a parse error", () => {
+  const { publicKeyB64 } = ed25519Pair();
+  const text = v2Rule(publicKeyB64, "ed25519", { signedBy: ["work", "ghost"] });
+  assert.throws(() => parseRule(text), /does not declare/);
+});
+
+test("trustedKeys entries are strictly validated", () => {
+  for (const bad of [
+    { alg: "rsa", publicKey: "x" },
+    { alg: "ed25519" },
+    { publicKey: "x" },
+    { alg: "ed25519", publicKey: "x", extra: 1 },
+  ]) {
+    const text = JSON.stringify({
+      rule: "bitgraph-player/2",
+      id: "r",
+      cast: { work: { digest: WORK } },
+      world: "closed",
+      requires: { ordering: "hash-linked" },
+      trustedKeys: { mike: bad },
+      claim: { exists: "work" },
+    });
+    assert.throws(() => parseRule(text), RuleError, JSON.stringify(bad));
+  }
+});
+
+test("pure-integer trusted key names are rejected", () => {
+  const text = JSON.stringify({
+    rule: "bitgraph-player/2",
+    id: "r",
+    cast: { work: { digest: WORK } },
+    world: "closed",
+    requires: { ordering: "hash-linked" },
+    trustedKeys: { "42": { alg: "ed25519", publicKey: "A".repeat(43) + "=" } },
+    claim: { exists: "work" },
+  });
+  assert.throws(() => parseRule(text), /non-digit/);
+});
+
+test("claimUsesSignatures walks the tree", () => {
+  assert.equal(claimUsesSignatures({ exists: "x" }), false);
+  assert.equal(
+    claimUsesSignatures({ all: [{ exists: "x" }, { not: { signedBy: ["x", "k"] } }] }),
+    true
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Signature file parsing
+// ---------------------------------------------------------------------------
+
+test("parseSigFile accepts a well-formed file and rejects noise", () => {
+  const { publicKeyB64, privateKey } = ed25519Pair();
+  const good = makeSigBytes("ed25519", publicKeyB64, privateKey, hexOfB64(WORK));
+  assert.notEqual(parseSigFile(good), undefined);
+  assert.equal(parseSigFile(Buffer.from("not json")), undefined);
+  assert.equal(parseSigFile(Buffer.from(JSON.stringify({ sig: "other/1" }))), undefined);
+  assert.equal(
+    parseSigFile(Buffer.from(JSON.stringify({ sig: "bitgraph-sig/1", over: "x", alg: "rsa" }))),
+    undefined
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Evaluation: ed25519 and es256
+// ---------------------------------------------------------------------------
+
+for (const alg of ["ed25519", "es256"] as const) {
+  test(`signedBy(${alg}): valid signature in evidence evaluates TRUE with derived math`, () => {
+    const pair = alg === "ed25519" ? ed25519Pair() : es256Pair();
+    const rule = parseRule(v2Rule(pair.publicKeyB64, alg, { signedBy: ["work", "mike"] }));
+    const audit = auditWithWork();
+    const evidence = evidenceOf(makeSigBytes(alg, pair.publicKeyB64, pair.privateKey, hexOfB64(WORK)));
+    const result = playAudit(rule, "0".repeat(64), audit, evidence);
+    assert.equal(result.verdict.result, "TRUE");
+    assert.equal(result.verdict.verdict, "bitgraph-player-verdict/2");
+    const step = result.verdict.derived.find((s) => s.claim.startsWith("signedBy"));
+    assert.ok(step !== undefined);
+    assert.equal((step as NonNullable<typeof step>).result, "TRUE");
+    // The binding is declared, alongside the math being derived.
+    const trusted = result.verdict.declared.find((d) => d.assertion === "trusted-key");
+    assert.ok(trusted !== undefined);
+    assert.equal((trusted as NonNullable<typeof trusted>)["keyName"], "mike");
+    assert.equal((trusted as NonNullable<typeof trusted>).verifiedHere, false);
+  });
+
+  test(`signedBy(${alg}): tampered signature is noise, evaluates UNDETERMINED`, () => {
+    const pair = alg === "ed25519" ? ed25519Pair() : es256Pair();
+    const rule = parseRule(v2Rule(pair.publicKeyB64, alg, { signedBy: ["work", "mike"] }));
+    const bytes = makeSigBytes(alg, pair.publicKeyB64, pair.privateKey, hexOfB64(WORK));
+    const parsed = JSON.parse(Buffer.from(bytes).toString("utf8")) as Record<string, string>;
+    const sigBytes = Buffer.from(parsed["signature"] as string, "base64");
+    sigBytes[0] = (sigBytes[0] as number) ^ 0xff;
+    parsed["signature"] = sigBytes.toString("base64");
+    const tampered = Buffer.from(JSON.stringify(parsed));
+    const result = playAudit(rule, "0".repeat(64), auditWithWork(), evidenceOf(tampered));
+    assert.equal(result.verdict.result, "UNDETERMINED");
+  });
+}
+
+test("a non-P-256 key declared as es256 is undecodable key material: UNDETERMINED, never a verify", () => {
+  const { publicKey, privateKey } = generateKeyPairSync("ec", { namedCurve: "secp384r1" });
+  const spki = (publicKey.export({ format: "der", type: "spki" }) as Buffer).toString("base64");
+  const rule = parseRule(v2Rule(spki, "es256", { signedBy: ["work", "mike"] }));
+  const evidence = evidenceOf(makeSigBytes("es256", spki, privateKey, hexOfB64(WORK)));
+  const result = playAudit(rule, "0".repeat(64), auditWithWork(), evidence);
+  assert.equal(result.verdict.result, "UNDETERMINED");
+  const step = result.verdict.derived.find((s) => s.claim.startsWith("signedBy"));
+  assert.ok(step !== undefined);
+  assert.match(String((step as NonNullable<typeof step>).because["reason"]), /not decodable/);
+});
+
+test("signedBy with empty evidence is UNDETERMINED, and not(signedBy) stays UNDETERMINED", () => {
+  const { publicKeyB64 } = ed25519Pair();
+  const rule = parseRule(v2Rule(publicKeyB64, "ed25519", { not: { signedBy: ["work", "mike"] } }));
+  const result = playAudit(rule, "0".repeat(64), auditWithWork());
+  // Never FALSE and never TRUE: the open world stays open.
+  assert.equal(result.verdict.result, "UNDETERMINED");
+});
+
+test("signedBy by the wrong key is UNDETERMINED, never FALSE", () => {
+  const right = ed25519Pair();
+  const wrong = ed25519Pair();
+  const rule = parseRule(v2Rule(right.publicKeyB64, "ed25519", { signedBy: ["work", "mike"] }));
+  const evidence = evidenceOf(
+    makeSigBytes("ed25519", wrong.publicKeyB64, wrong.privateKey, hexOfB64(WORK))
+  );
+  const result = playAudit(rule, "0".repeat(64), auditWithWork(), evidence);
+  assert.equal(result.verdict.result, "UNDETERMINED");
+});
+
+test("signedBy over a different digest does not satisfy the role's claim", () => {
+  const pair = ed25519Pair();
+  const rule = parseRule(v2Rule(pair.publicKeyB64, "ed25519", { signedBy: ["work", "mike"] }));
+  const other = digestFor("other");
+  const evidence = evidenceOf(
+    makeSigBytes("ed25519", pair.publicKeyB64, pair.privateKey, hexOfB64(other))
+  );
+  const result = playAudit(rule, "0".repeat(64), auditWithWork(), evidence);
+  assert.equal(result.verdict.result, "UNDETERMINED");
+});
+
+test("signedBy evaluates against the declared digest even when the role has no recording", () => {
+  const pair = ed25519Pair();
+  const text = JSON.stringify({
+    rule: "bitgraph-player/2",
+    id: "r",
+    cast: { work: { digest: WORK, optional: true } },
+    world: "closed",
+    requires: { ordering: "hash-linked" },
+    trustedKeys: { mike: { alg: "ed25519", publicKey: pair.publicKeyB64 } },
+    claim: { signedBy: ["work", "mike"] },
+  });
+  const rule = parseRule(text);
+  const audit = makeAudit({ proofs: [], partitions: [] });
+  const evidence = evidenceOf(
+    makeSigBytes("ed25519", pair.publicKeyB64, pair.privateKey, hexOfB64(WORK))
+  );
+  const resolutions = resolveCast(rule.cast, audit);
+  const evaluation = evaluate(rule, resolutions, audit, evidence);
+  assert.equal(evaluation.result, "TRUE");
+});
+
+test("a /1 rule still yields a /1 verdict and ignores supplied evidence", () => {
+  const text = JSON.stringify({
+    rule: "bitgraph-player/1",
+    id: "r",
+    cast: { work: { digest: WORK } },
+    world: "closed",
+    requires: { ordering: "assumption-dependent" },
+    claim: { exists: "work" },
+  });
+  const rule = parseRule(text);
+  const result = playAudit(rule, "0".repeat(64), auditWithWork(), evidenceOf(Buffer.from("junk")));
+  assert.equal(result.verdict.verdict, "bitgraph-player-verdict/1");
+  assert.equal(result.verdict.result, "TRUE");
+});
+
+test("multiple candidates: the winner is deterministic and reported by content hash", () => {
+  const pair = ed25519Pair();
+  const rule = parseRule(v2Rule(pair.publicKeyB64, "ed25519", { signedBy: ["work", "mike"] }));
+  const sig = makeSigBytes("ed25519", pair.publicKeyB64, pair.privateKey, hexOfB64(WORK));
+  const junk = Buffer.from("{}");
+  const a = playAudit(rule, "0".repeat(64), auditWithWork(), evidenceOf(sig, junk));
+  const b = playAudit(rule, "0".repeat(64), auditWithWork(), evidenceOf(junk, sig));
+  assert.equal(a.bytes, b.bytes);
+});

package/src/evaluate.ts

@@ -21,9 +21,12 @@
  *   that evidence in either direction.
  */
 
+import type { KeyObject } from "node:crypto";
 import type { AuditResult, ObservedProof } from "@mikeargento/bitgraph-audit";
 import { kleeneAll, kleeneAny, kleeneNot } from "./logic.js";
 import { compare } from "./order.js";
+import { decodeDigestBytes, normalizeDigest } from "./rule.js";
+import { keyObjectFor, parseSigFile, verifySigFile } from "./sig.js";
 import { basisTier, meetsFloor } from "./types.js";
 import type {
   Claim,
@@ -41,12 +44,22 @@ export interface Evaluation {
   weakestEvidence?: EvidenceTier;
 }
 
+/**
+ * Signature evidence for format-2 signedBy claims: candidate file bytes
+ * keyed by lowercase hex SHA-256. Collected by the caller (play() streams
+ * size-capped matched artifacts from the bundle); evaluate() itself stays
+ * a pure function over its arguments.
+ */
+export type SigEvidence = ReadonlyMap<string, Uint8Array>;
+
 interface Ctx {
   rule: Rule;
   resolutions: Map<string, Resolution>;
   audit: AuditResult;
   steps: DerivedStep[];
   usedTiers: Set<EvidenceTier>;
+  sigEvidence: SigEvidence;
+  keyObjects: Map<string, KeyObject | undefined>;
 }
 
 function positionOf(proof: ObservedProof): Record<string, unknown> {
@@ -198,8 +211,91 @@ function evalPrecedes(ctx: Ctx, claim: string, x: string, y: string): ThreeValue
   });
 }
 
+/**
+ * signedBy(role, keyName): TRUE when a valid bitgraph-sig/1 by the named
+ * trusted key over the role's digest is present in the supplied evidence;
+ * UNDETERMINED otherwise, NEVER FALSE. Absence of a signature from a
+ * bundle proves nothing about the world, and `not(signedBy(...))` is
+ * therefore permanently UNDETERMINED by the Kleene table.
+ *
+ * The claim is about BITS, not occurrences: it evaluates against the
+ * declared role digest whether or not the role resolved to a recording.
+ * Only an undeclared role is UNDETERMINED for want of a digest.
+ */
+function evalSignedBy(ctx: Ctx, role: string, keyName: string): ThreeValued {
+  const claim = `signedBy(${role}, ${keyName})`;
+  const entry = ctx.rule.cast[role];
+  if (entry === undefined) {
+    return record(ctx, {
+      claim,
+      result: "UNDETERMINED",
+      because: { reason: `role "${role}" is not declared in the cast` },
+    });
+  }
+  // parseRule guarantees the key name resolves; guard for direct API use.
+  const key = ctx.rule.trustedKeys?.[keyName];
+  if (key === undefined) {
+    return record(ctx, {
+      claim,
+      result: "UNDETERMINED",
+      because: { reason: `trusted key "${keyName}" is not declared` },
+    });
+  }
+  if (!ctx.keyObjects.has(keyName)) ctx.keyObjects.set(keyName, keyObjectFor(key));
+  const keyObject = ctx.keyObjects.get(keyName);
+  if (keyObject === undefined) {
+    return record(ctx, {
+      claim,
+      result: "UNDETERMINED",
+      because: {
+        reason: `trusted key "${keyName}" is not decodable as ${key.alg} key material; no signature can verify against it`,
+      },
+    });
+  }
+
+  const digestB64 = normalizeDigest(entry.digest) as string;
+  const targetHex = (decodeDigestBytes(digestB64) as Buffer).toString("hex");
+
+  // Deterministic scan: candidates in ascending content-hash order.
+  const candidates = [...ctx.sigEvidence.keys()].sort();
+  let parsedCount = 0;
+  for (const sha256Hex of candidates) {
+    const bytes = ctx.sigEvidence.get(sha256Hex) as Uint8Array;
+    const sig = parseSigFile(bytes);
+    if (sig === undefined) continue;
+    parsedCount += 1;
+    if (verifySigFile(sig, key, keyObject, targetHex, decodeDigestBytes)) {
+      return record(ctx, {
+        claim,
+        result: "TRUE",
+        because: {
+          signatureSha256Hex: sha256Hex,
+          alg: key.alg,
+          keyName,
+          over: `sha256:${targetHex}`,
+          note: "signature math verified here; that this key belongs to the named party is declared, never derived",
+        },
+      });
+    }
+  }
+  return record(ctx, {
+    claim,
+    result: "UNDETERMINED",
+    because: {
+      reason:
+        `no valid bitgraph-sig/1 by trusted key "${keyName}" over the role digest is present in the ` +
+        `supplied evidence (${ctx.sigEvidence.size} candidate file(s), ${parsedCount} parsed as signatures); ` +
+        `absence of a signature from a bundle proves nothing`,
+    },
+  });
+}
+
 function evalClaim(ctx: Ctx, claim: Claim): ThreeValued {
   if ("exists" in claim) return evalExists(ctx, claim.exists);
+  if ("signedBy" in claim) {
+    const [role, keyName] = claim.signedBy;
+    return evalSignedBy(ctx, role, keyName);
+  }
   if ("before" in claim) {
     const [x, y] = claim.before;
     return evalPrecedes(ctx, `before(${x}, ${y})`, x, y);
@@ -224,9 +320,18 @@ function evalClaim(ctx: Ctx, claim: Claim): ThreeValued {
 export function evaluate(
   rule: Rule,
   resolutions: Map<string, Resolution>,
-  audit: AuditResult
+  audit: AuditResult,
+  sigEvidence: SigEvidence = new Map()
 ): Evaluation {
-  const ctx: Ctx = { rule, resolutions, audit, steps: [], usedTiers: new Set() };
+  const ctx: Ctx = {
+    rule,
+    resolutions,
+    audit,
+    steps: [],
+    usedTiers: new Set(),
+    sigEvidence,
+    keyObjects: new Map(),
+  };
   const result = evalClaim(ctx, rule.claim);
   const evaluation: Evaluation = { result, steps: ctx.steps };
   if (ctx.usedTiers.has("assumption-dependent")) {

package/src/index.ts

@@ -5,7 +5,7 @@
  *
  * Deterministic evaluation of causal rules over BitGraph proof bundles.
  *
- *   BitGraph records. Player executes.
+ *   BitGraph records. Player evaluates.
  *
  * Player is a pure function over `runAudit()`'s output: same rule, same
  * bundle, same verdict, on anyone's machine, with no network access at
@@ -24,14 +24,18 @@ export type {
   OrderResult,
   Resolution,
   Rule,
+  RuleFormat,
   ThreeValued,
   Verdict,
 } from "./types.js";
 export { basisTier, meetsFloor } from "./types.js";
 
-export { parseRule, normalizeDigest, RuleError } from "./rule.js";
-export { play, playAudit, PlayError } from "./play.js";
+export { parseRule, normalizeDigest, decodeDigestBytes, RuleError } from "./rule.js";
+export { play, playAudit, claimUsesSignatures, SIG_EVIDENCE_MAX_BYTES, PlayError } from "./play.js";
 export type { PlayResult, PlayStage } from "./play.js";
+export { parseSigFile, verifySigFile, keyObjectFor, sigMessage } from "./sig.js";
+export type { SigAlg, SigFile, TrustedKey } from "./sig.js";
+export type { SigEvidence } from "./evaluate.js";
 export { scaffoldRule, roleNameForFile, ORDERING_PLACEHOLDER } from "./init.js";
 export type { ScaffoldEntry } from "./init.js";
 export { resolveCast, resolveRole } from "./cast.js";