@mikeargento/bitgraph-player 0.2.1 → 0.3.0

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.1";
+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.1";
+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":"AAAA,qFAAqF;AAqBrF,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAG5C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC,wCAAwC;AACxC,MAAM,UAAU,aAAa;IAC3B,OAAO,cAAc,CAAC;AACxB,CAAC;AAED,SAAS,eAAe,CAAC,GAAe;IACtC,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,KAAK,UAAU;YACb,OAAO,UAAU,CAAC;QACpB,KAAK,QAAQ;YACX,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB,CAAC;QAC9D,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QACrB,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAC1B,IAAU,EACV,aAAqB,EACrB,WAAoC,EACpC,UAAsB,EACtB,KAAkB;IAElB,qEAAqE;IACrE,6CAA6C;IAC7C,MAAM,IAAI,GAAoB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAoB,CAAC;IACrE,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAe,CAAC;QAChD,MAAM,OAAO,GAA4B;YACvC,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,MAAM,CAAW;YAClD,UAAU,EAAE,eAAe,CAAC,GAAG,CAAC;SACjC,CAAC;QACF,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC5B,OAAO,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC;YACxC,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS;gBAAE,OAAO,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;YACzE,OAAO,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;YACpC,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS;gBAAE,OAAO,CAAC,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC;YACzE,IAAI,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS;gBAAE,OAAO,CAAC,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;QACvF,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;IACvB,CAAC;IAED,qEAAqE;IACrE,MAAM,QAAQ,GAAoB,EAAE,CAAC;IACrC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC9B,QAAQ,CAAC,IAAI,CAAC;gBACZ,SAAS,EAAE,OAAO;gBAClB,IAAI;gBACJ,YAAY,EAAE,KAAK;gBACnB,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,SAAS,EAAE,eAAe,CAAC,KAAK,CAAC,MAAM,CAAW;aACnD,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,IAAI,KAAK,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;YAC3B,QAAQ,CAAC,IAAI,CAAC;gBACZ,SAAS,EAAE,mBAAmB;gBAC9B,IAAI;gBACJ,YAAY,EAAE,KAAK;gBACnB,EAAE,EAAE,KAAK,CAAC,EAAE;aACb,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACjC,QAAQ,CAAC,IAAI,CAAC;gBACZ,SAAS,EAAE,UAAU;gBACrB,IAAI;gBACJ,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,uEAAuE;IACvE,qEAAqE;IACrE,sEAAsE;IACtE,oBAAoB;IACpB,IAAI,IAAI,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACnC,KAAK,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9D,QAAQ,CAAC,IAAI,CAAC;gBACZ,SAAS,EAAE,aAAa;gBACxB,YAAY,EAAE,KAAK;gBACnB,OAAO;gBACP,GAAG,EAAE,GAAG,CAAC,GAAG;gBACZ,SAAS,EAAE,GAAG,CAAC,SAAS;aACzB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,QAAQ,CAAC,IAAI,CAAC;QACZ,SAAS,EAAE,cAAc;QACzB,YAAY,EAAE,KAAK;QACnB,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM;QACvC,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ;QAChD,KAAK,EACH,yKAAyK;KAC5K,CAAC,CAAC;IAEH,MAAM,OAAO,GAAY;QACvB,OAAO,EACL,IAAI,CAAC,IAAI,KAAK,mBAAmB,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,2BAA2B;QAC/F,MAAM,EAAE,UAAU,CAAC,MAAM;QACzB,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE;QAC5C,IAAI;QACJ,OAAO,EAAE,UAAU,CAAC,KAAK;QACzB,QAAQ;QACR,SAAS,EAAE,EAAE,IAAI,EAAE,8BAA8B,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE;QAC7E,OAAO,EAAE,MAAM;KAChB,CAAC;IACF,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACtD,IAAI,UAAU,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QAC7C,OAAO,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;IACvD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAgB;IAC/C,6DAA6D;IAC7D,kEAAkE;IAClE,MAAM,OAAO,GAA4B;QACvC,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,IAAI,EAAE,OAAO,CAAC,IAAI;KACnB,CAAC;IACF,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAC/D,IAAI,OAAO,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;QAC1C,OAAO,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IACvD,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAC/B,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IACrC,OAAO,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC;IACvC,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;IACzC,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;AACjD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeargento/bitgraph-player",
-  "version": "0.2.1",
+  "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

@@ -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";

package/src/play.ts

@@ -16,12 +16,13 @@
 
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { runAudit } from "@mikeargento/bitgraph-audit";
+import { runAudit, streamMatchedArtifacts } from "@mikeargento/bitgraph-audit";
 import type { AuditResult } from "@mikeargento/bitgraph-audit";
 import { resolveCast } from "./cast.js";
 import { evaluate } from "./evaluate.js";
+import type { SigEvidence } from "./evaluate.js";
 import { parseRule } from "./rule.js";
-import type { Rule, Verdict } from "./types.js";
+import type { Claim, Rule, Verdict } from "./types.js";
 import { buildVerdict, serializeVerdict } from "./verdict.js";
 
 export type PlayStage = "rule-read" | "audit";
@@ -45,10 +46,32 @@ export interface PlayResult {
   audit: AuditResult;
 }
 
+/** True when the claim tree contains a signedBy claim anywhere. */
+export function claimUsesSignatures(claim: Claim): boolean {
+  if ("signedBy" in claim) return true;
+  if ("all" in claim) return claim.all.some(claimUsesSignatures);
+  if ("any" in claim) return claim.any.some(claimUsesSignatures);
+  if ("not" in claim) return claimUsesSignatures(claim.not);
+  return false;
+}
+
+/**
+ * Ceiling on candidate signature-file bytes retained for signedBy
+ * evaluation. Signature files are a few hundred bytes; the cap only
+ * exists so a bundle full of large artifacts never inflates memory.
+ * A file above the cap is simply not signature evidence.
+ */
+export const SIG_EVIDENCE_MAX_BYTES = 1_048_576;
+
 /** The pure tail of the pipeline: no filesystem, no network. */
-export function playAudit(rule: Rule, ruleSha256Hex: string, audit: AuditResult): PlayResult {
+export function playAudit(
+  rule: Rule,
+  ruleSha256Hex: string,
+  audit: AuditResult,
+  sigEvidence: SigEvidence = new Map()
+): PlayResult {
   const resolutions = resolveCast(rule.cast, audit);
-  const evaluation = evaluate(rule, resolutions, audit);
+  const evaluation = evaluate(rule, resolutions, audit, sigEvidence);
   const verdict = buildVerdict(rule, ruleSha256Hex, resolutions, evaluation, audit);
   const exitCode = evaluation.result === "TRUE" ? 0 : evaluation.result === "FALSE" ? 1 : 2;
   return { verdict, bytes: serializeVerdict(verdict), exitCode, audit };
@@ -74,5 +97,20 @@ export async function play(rulePath: string, bundlePath: string): Promise<PlayRe
   } catch (err) {
     throw new PlayError("audit", `bundle audit failed: ${(err as Error).message}`, err);
   }
-  return playAudit(rule, ruleSha256Hex, audit);
+
+  // Format 2 with signature claims: candidate evidence is every RECORDED
+  // artifact in the bundle (matched to a proof), size-capped. A signature
+  // that was never recorded can still be supplied to playAudit directly
+  // by an embedder; the reference CLI evaluates recorded evidence, which
+  // is what a Titles thread produces by construction.
+  let sigEvidence: SigEvidence | undefined;
+  if (rule.rule === "bitgraph-player/2" && claimUsesSignatures(rule.claim)) {
+    const collected = new Map<string, Uint8Array>();
+    for await (const matched of streamMatchedArtifacts(audit.ingest)) {
+      if (matched.bytes.length > SIG_EVIDENCE_MAX_BYTES) continue;
+      if (!collected.has(matched.sha256Hex)) collected.set(matched.sha256Hex, matched.bytes);
+    }
+    sigEvidence = collected;
+  }
+  return playAudit(rule, ruleSha256Hex, audit, sigEvidence);
 }