progmune-runtime 2.0.4 → 2.1.0

package/dist/protocol-registry.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Phase 6C: Single Source of Protocol Truth
+ *
+ * ALL components read namespaceInitialStates, rules, ruleHash, and version
+ * from here. No component may hardcode default states or read protocols.json directly.
+ *
+ * Usage:
+ *   import { getProtocolConfig } from "./protocol-registry";
+ *   const { nsInit, rules, ruleHash, version } = getProtocolConfig();
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateProtocolCache = invalidateProtocolCache;
+exports.getProtocolConfig = getProtocolConfig;
+exports.getNsInit = getNsInit;
+exports.getRuleHash = getRuleHash;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ssg_validator_1 = require("./ssg-validator");
+// ── Singleton cache ──
+let cached = null;
+/** Invalidate the cache (call after protocols.json changes). */
+function invalidateProtocolCache() {
+    cached = null;
+}
+/** Get the authoritative protocol configuration.
+ *  Cached after first call; call invalidateProtocolCache() to force reload. */
+function getProtocolConfig() {
+    if (cached)
+        return cached;
+    const nsInit = new Map();
+    let rules = [];
+    let version = "1.0";
+    const protoPath = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), "protocols.json");
+    if (fs.existsSync(protoPath)) {
+        try {
+            const proto = JSON.parse(fs.readFileSync(protoPath, "utf-8"));
+            version = proto.$schema || proto.version || "1.0";
+            // Load namespace initial states
+            nsInit.set("_global", "UNAUTHENTICATED");
+            if (proto.namespaceInitialStates) {
+                for (const [ns, state] of Object.entries(proto.namespaceInitialStates)) {
+                    nsInit.set(ns, state);
+                }
+            }
+            // Parse rules
+            rules = (0, ssg_validator_1.parseProtocolsFromJSON)(proto);
+        }
+        catch { }
+    }
+    else {
+        // Fallback: minimal defaults (no protocols.json found)
+        nsInit.set("_global", "UNAUTHENTICATED");
+    }
+    // Compute rule hash
+    const ruleMap = new Map();
+    for (const r of rules) {
+        ruleMap.set(r.function, r.protocol);
+    }
+    const ruleHash = (0, ssg_validator_1.hashRules)(ruleMap);
+    cached = { nsInit, rules, ruleHash, version };
+    return cached;
+}
+// ── Convenience re-exports ──
+/** Get namespace initial states only (most common need). */
+function getNsInit() {
+    return new Map(getProtocolConfig().nsInit);
+}
+/** Get current rule hash without loading full config. */
+function getRuleHash() {
+    return getProtocolConfig().ruleHash;
+}

package/dist/recent-session.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343925827_zga2j timestamp=2026-06-01T19:58:47.097Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 398 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const sessions = (0, failure_corpus_1.getAllSessions)();
+    const idx = findIndex();
+    return sessions;
+}
+main();

package/dist/repair-proposal.js

@@ -0,0 +1,353 @@
+"use strict";
+/**
+ * Phase 4: Repair Proposal Engine (P2)
+ *
+ * Suggests repairs for detected violations — but NEVER auto-writes to the Ledger.
+ * Ledger = Evidence, not Cache.
+ *
+ * Three proposal strategies:
+ *   insert  — missing step detected, insert function call before violation
+ *   replace — transition has incorrect state data, replace it
+ *   reorder — wrong call order, propose reordering
+ *
+ * The engine produces Proposal JSON. The caller (Planner, human, future Repair Planner)
+ * decides whether to accept and create a Branch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestRepairs = suggestRepairs;
+exports.suggestProtocolRepair = suggestProtocolRepair;
+exports.suggestInvariantRepair = suggestInvariantRepair;
+exports.applyProposalAsBranch = applyProposalAsBranch;
+exports.validateProposal = validateProposal;
+exports.generateRepairSummary = generateRepairSummary;
+exports.getMinimalFixSet = getMinimalFixSet;
+const ssg_validator_1 = require("./ssg-validator");
+const runtime_invariants_1 = require("./runtime-invariants");
+const protocol_registry_1 = require("./protocol-registry");
+const branch_ledger_1 = require("./branch-ledger");
+// ── Proposal Generation ──
+/** Generate repair proposals for all detected violations in a ledger. */
+function suggestRepairs(violations, ir, protocols) {
+    const proposals = [];
+    for (const v of violations) {
+        if (v.violatedConstraint === "protocol") {
+            const rejection = tryParseRejection(v);
+            if (rejection) {
+                proposals.push(...suggestProtocolRepair(rejection, ir));
+                continue;
+            }
+        }
+        // Generic violation: suggest based on SVL level
+        proposals.push(suggestGenericRepair(v, ir));
+    }
+    return proposals;
+}
+/** Protocol violation repair: use SSG fixPath to suggest insertions. */
+function suggestProtocolRepair(rejection, ir) {
+    const proposals = [];
+    if (rejection.fixPath && rejection.fixPath.length > 0) {
+        // Each missing function in the fix path is a separate insert proposal
+        for (let i = 0; i < rejection.fixPath.length; i++) {
+            const fnName = rejection.fixPath[i];
+            const def = ir.find((f) => f.name === fnName);
+            const actions = [];
+            if (def) {
+                const args = (def.params || []).map((p, j) => ({
+                    name: p.name || `p${j}`,
+                    type: p.type || "any",
+                    value: "",
+                }));
+                const action = {
+                    kind: "call",
+                    function: fnName,
+                    args,
+                };
+                if (def.returnType && def.returnType !== "void" && def.returnType !== "undefined") {
+                    action.assignTo = `${fnName}_result`;
+                }
+                actions.push(action);
+            }
+            proposals.push({
+                id: `rp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+                violationIndex: 0, // protocol violations don't have a specific transition index
+                reason: `Protocol violation: ${rejection.blocked} requires ${fnName}`,
+                strategy: "insert",
+                insertBefore: undefined, // caller decides exact position
+                proposedActions: actions,
+                confidence: 0.85 + (i * 0.05), // later steps in fixPath have higher confidence
+                explanation: `Insert ${fnName} before ${rejection.blocked}. Missing states: [${(rejection.missingFunctions || []).join(", ")}]. Fix path: ${rejection.fixPath.join(" → ")}`,
+            });
+        }
+    }
+    // If no fixPath but missing functions are known, propose searching
+    if (proposals.length === 0 && rejection.missingFunctions && rejection.missingFunctions.length > 0) {
+        proposals.push({
+            id: `rp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+            violationIndex: 0,
+            reason: `Protocol violation: ${rejection.blocked} blocked`,
+            strategy: "insert",
+            proposedActions: [],
+            confidence: 0.5,
+            explanation: `Cannot determine fix path. Blocked function: ${rejection.blocked}. Required states: [${(rejection.requiredState || []).join(", ")}]. Current states: [${(rejection.currentState || []).join(", ")}].`,
+        });
+    }
+    return proposals;
+}
+/** Invariant violation repair: use rebuildState to compute correct transition data. */
+function suggestInvariantRepair(violation, ledger, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    const proposals = [];
+    if (violation.invariant === "before-consistency") {
+        // statesBefore is wrong — can be recomputed from rebuildState
+        const correctStatesBefore = violation.expected;
+        const t = ledger[violation.index];
+        if (!t)
+            return [];
+        const correctedTransition = {
+            ...t,
+            statesBefore: correctStatesBefore,
+        };
+        // Ontology: verify corrected transition passes delta consistency
+        try {
+            (0, runtime_invariants_1.assertDeltaConsistency)(correctedTransition);
+        }
+        catch { }
+        proposals.push({
+            id: `rp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+            violationIndex: violation.index,
+            reason: `Invariant-0 (before-consistency): statesBefore mismatch at index ${violation.index}`,
+            strategy: "replace",
+            replacement: correctedTransition,
+            proposedActions: [], // no new actions needed — just correct the record
+            confidence: 0.95,
+            explanation: `Transition[${violation.index}] "${t.function}" has incorrect statesBefore. Expected: ${JSON.stringify(correctStatesBefore[t.namespace] || [])}. This is likely a recording error, not a code error.`,
+        });
+    }
+    if (violation.invariant === "delta-consistency") {
+        // statesAfter doesn't match applyDelta(statesBefore, acquired, invalidated)
+        const correctStatesAfter = violation.expected;
+        const t = ledger[violation.index];
+        if (!t)
+            return [];
+        const correctedTransition = {
+            ...t,
+            statesAfter: correctStatesAfter,
+        };
+        try {
+            (0, runtime_invariants_1.assertDeltaConsistency)(correctedTransition);
+        }
+        catch { }
+        proposals.push({
+            id: `rp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+            violationIndex: violation.index,
+            reason: `Invariant-1 (delta-consistency): statesAfter mismatch at index ${violation.index}`,
+            strategy: "replace",
+            replacement: correctedTransition,
+            proposedActions: [],
+            confidence: 0.95,
+            explanation: `Transition[${violation.index}] "${t.function}" statesAfter does not match applyDelta(statesBefore). Expected: ${JSON.stringify(correctStatesAfter[t.namespace] || [])}. The acquire/invalidate fields may also need recomputation.`,
+        });
+    }
+    return proposals;
+}
+/** Generic repair for SVL-1/SVL-2/SVL-3 violations. */
+function suggestGenericRepair(violation, ir) {
+    const base = {
+        id: `rp_${Date.now()}_${Math.random().toString(36).slice(2, 5)}`,
+        violationIndex: violation.actionIndex,
+        proposedActions: [],
+    };
+    switch (violation.violatedConstraint) {
+        case "symbol_existence": {
+            // Find closest matching function in IR
+            const missingName = violation.missingStates?.[0] || "unknown";
+            let bestMatch = "";
+            let bestScore = 0;
+            for (const fn of ir) {
+                const score = jaccardSimilarity(missingName.toLowerCase(), fn.name.toLowerCase());
+                if (score > bestScore && score >= 0.3) {
+                    bestScore = score;
+                    bestMatch = fn.name;
+                }
+            }
+            if (bestMatch) {
+                const def = ir.find((f) => f.name === bestMatch);
+                const args = (def?.params || []).map((p, j) => ({
+                    name: p.name || `p${j}`,
+                    type: p.type || "any",
+                    value: "",
+                }));
+                return {
+                    ...base,
+                    reason: `SVL-1: function "${missingName}" does not exist`,
+                    strategy: "replace",
+                    proposedActions: [{ kind: "call", function: bestMatch, args }],
+                    confidence: 0.7 + bestScore * 0.3,
+                    explanation: `Replace "${missingName}" with the closest real function "${bestMatch}" (similarity: ${(bestScore * 100).toFixed(0)}%).`,
+                };
+            }
+            return {
+                ...base,
+                reason: `SVL-1: function "${missingName}" does not exist`,
+                strategy: "replace",
+                confidence: 0.1,
+                explanation: `Cannot find a matching function for "${missingName}" in the IR. Manual intervention required.`,
+            };
+        }
+        case "type_mismatch":
+            return {
+                ...base,
+                reason: `SVL-2: type/parameter mismatch`,
+                strategy: "replace",
+                confidence: 0.6,
+                explanation: `Action[${violation.actionIndex}] has incorrect parameter types or count. Check the function signature in IR and adjust args accordingly.`,
+            };
+        case "dataflow":
+            return {
+                ...base,
+                reason: `SVL-3: dataflow violation`,
+                strategy: "reorder",
+                confidence: 0.5,
+                explanation: `Action[${violation.actionIndex}] uses a variable before it's defined, or creates a circular reference. Reorder actions or add an assignment.`,
+            };
+        default:
+            return {
+                ...base,
+                reason: `Unknown violation: ${violation.violatedConstraint}`,
+                strategy: "replace",
+                confidence: 0.1,
+                explanation: violation.description,
+            };
+    }
+}
+// ── Proposal → Branch Bridge ──
+/** Convert an accepted repair proposal into a new Branch.
+ *  Creates a child branch with the proposed fix applied.
+ *  The original ledger is never modified. */
+function applyProposalAsBranch(proposal, parentBranch, currentLedger, ir) {
+    const branch = (0, branch_ledger_1.createBranch)(parentBranch, "repair_attempt");
+    switch (proposal.strategy) {
+        case "insert": {
+            if (proposal.insertBefore !== undefined && proposal.insertBefore < currentLedger.length) {
+                // Insert proposed actions before the violation point
+                const before = currentLedger.slice(0, proposal.insertBefore);
+                const after = currentLedger.slice(proposal.insertBefore);
+                // Create placeholder transitions for inserted actions
+                const newTransitions = proposal.proposedActions.map((a, i) => ({
+                    actionIndex: proposal.insertBefore + i,
+                    function: a.kind === "call" ? a.function : a.kind,
+                    namespace: "_global",
+                    acquired: [],
+                    invalidated: [],
+                    statesBefore: {},
+                    statesAfter: {},
+                    valid: true,
+                }));
+                branch.transitions = [...before, ...newTransitions, ...after];
+            }
+            else {
+                branch.transitions = [...currentLedger];
+            }
+            break;
+        }
+        case "replace": {
+            if (proposal.replacement && proposal.violationIndex < currentLedger.length) {
+                branch.transitions = currentLedger.map((t, i) => i === proposal.violationIndex ? proposal.replacement : t);
+            }
+            else {
+                branch.transitions = [...currentLedger];
+            }
+            break;
+        }
+        case "reorder": {
+            if (proposal.newOrder) {
+                branch.transitions = proposal.newOrder.map(i => currentLedger[i]);
+            }
+            else {
+                branch.transitions = [...currentLedger];
+            }
+            break;
+        }
+        default:
+            branch.transitions = [...currentLedger];
+    }
+    return branch;
+}
+// ── Validation ──
+/** Validate a repair proposal: does applying it fix the violation?
+ *  Returns true if a re-check passes after applying the proposal. */
+function validateProposal(proposal, currentLedger, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    let proposedLedger;
+    switch (proposal.strategy) {
+        case "replace":
+            proposedLedger = currentLedger.map((t, i) => i === proposal.violationIndex && proposal.replacement ? proposal.replacement : t);
+            break;
+        case "reorder":
+            proposedLedger = proposal.newOrder
+                ? proposal.newOrder.map(i => currentLedger[i])
+                : [...currentLedger];
+            break;
+        case "insert":
+        default:
+            proposedLedger = [...currentLedger];
+    }
+    const result = (0, ssg_validator_1.checkLedgerConsistency)(proposedLedger, namespaceInitialStates);
+    return {
+        valid: result.consistent,
+        remainingViolations: result.violations,
+    };
+}
+// ── Summary ──
+/** Generate a comprehensive repair summary from a ledger and IR context. */
+function generateRepairSummary(ledger, ir, protocols, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    const consistency = (0, ssg_validator_1.checkLedgerConsistency)(ledger, namespaceInitialStates);
+    const allProposals = [];
+    // Generate invariant repair proposals
+    for (const v of consistency.violations) {
+        allProposals.push(...suggestInvariantRepair(v, ledger, namespaceInitialStates));
+    }
+    const minimalFixSet = getMinimalFixSet(allProposals);
+    return {
+        totalViolations: consistency.violations.length,
+        proposals: allProposals,
+        minimalFixSet,
+    };
+}
+/**
+ * Deduplicate repair proposals: pick the highest-confidence proposal per violation index.
+ * Returns proposals sorted by violationIndex (ascending).
+ *
+ * This is the authoritative "minimal fix set" — applying these proposals in order
+ * should resolve all detected violations without redundant fixes.
+ */
+function getMinimalFixSet(proposals) {
+    const seen = new Map();
+    for (const p of proposals) {
+        const existing = seen.get(p.violationIndex);
+        if (!existing || p.confidence > existing.confidence) {
+            seen.set(p.violationIndex, p);
+        }
+    }
+    return [...seen.values()].sort((a, b) => a.violationIndex - b.violationIndex);
+}
+// ── Helpers ──
+function tryParseRejection(v) {
+    try {
+        if (v.description) {
+            const parsed = JSON.parse(v.description);
+            if (parsed.protocol_violation) {
+                return parsed.protocol_violation;
+            }
+        }
+    }
+    catch {
+        // Not JSON — try to extract from description string
+    }
+    return null;
+}
+function jaccardSimilarity(a, b) {
+    const setA = new Set(a.split(""));
+    const setB = new Set(b.split(""));
+    const intersection = new Set([...setA].filter(x => setB.has(x)));
+    const union = new Set([...setA, ...setB]);
+    return union.size === 0 ? 0 : intersection.size / union.size;
+}

package/dist/runtime-invariants.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Phase 4: Runtime Invariant Assertion Layer
+ *
+ * Centralized invariant enforcement. All invariant checks → throw on failure.
+ * Replaces scattered console.error() with structured InvariantViolationError.
+ *
+ * Controlled by PROGMUNE_STRICT env var (default: true in dev/ci).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvariantViolationError = void 0;
+exports.assertLedgerConsistency = assertLedgerConsistency;
+exports.assertDeltaConsistency = assertDeltaConsistency;
+exports.assertRuleHashMatch = assertRuleHashMatch;
+exports.assertTransitionOrder = assertTransitionOrder;
+exports.assertLedgerInvariants = assertLedgerInvariants;
+const ssg_validator_1 = require("./ssg-validator");
+const protocol_registry_1 = require("./protocol-registry");
+// Re-export for convenient import
+var ssg_validator_2 = require("./ssg-validator");
+Object.defineProperty(exports, "InvariantViolationError", { enumerable: true, get: function () { return ssg_validator_2.InvariantViolationError; } });
+// ── Config ──
+const STRICT = process.env.PROGMUNE_STRICT !== "false";
+const isStrict = () => STRICT;
+// ── Assertions ──
+/** Assert full ledger passes Invariant-0 + Invariant-1.
+ *  Throws InvariantViolationError with the first violation's details. */
+function assertLedgerConsistency(ledger, namespaceInitialStates = (0, protocol_registry_1.getNsInit)()) {
+    if (ledger.length === 0)
+        return;
+    const result = (0, ssg_validator_1.checkLedgerConsistency)(ledger, namespaceInitialStates);
+    if (result.consistent)
+        return;
+    if (!isStrict()) {
+        console.error(`[Invariant] Ledger consistency: ${result.violations.length} violation(s) detected (PROGMUNE_STRICT=false — not throwing)`);
+        for (const v of result.violations) {
+            console.error(`  [${v.invariant}] index=${v.index}: ${v.detail || ""}`);
+        }
+        return;
+    }
+    const first = result.violations[0];
+    const msg = result.violations.length === 1
+        ? `Ledger invariant violation: [${first.invariant}] at index ${first.index}`
+        : `Ledger invariant violation: ${result.violations.length} violations, first: [${first.invariant}] at index ${first.index}`;
+    throw new ssg_validator_1.InvariantViolationError(msg, {
+        invariant: first.invariant,
+        index: first.index,
+        expected: first.expected,
+        actual: first.actual,
+    });
+}
+/** Assert a single transition's delta consistency.
+ *  Checks that applying acquire/invalidate to statesBefore produces statesAfter. */
+function assertDeltaConsistency(transition) {
+    if (!transition.valid)
+        return;
+    // Replay: apply the delta to statesBefore, compare with statesAfter
+    const fromSnapshot = (snap) => {
+        const map = new Map();
+        for (const [ns, states] of Object.entries(snap)) {
+            map.set(ns, new Set(states));
+        }
+        return map;
+    };
+    const toSnapshot = (stateMap) => {
+        const snap = {};
+        for (const [ns, states] of stateMap) {
+            snap[ns] = [...states].sort();
+        }
+        return snap;
+    };
+    const deltaMap = fromSnapshot(transition.statesBefore);
+    for (const s of transition.acquired) {
+        const ns = transition.namespace;
+        if (!deltaMap.has(ns))
+            deltaMap.set(ns, new Set());
+        deltaMap.get(ns).add(s);
+    }
+    for (const s of transition.invalidated) {
+        const ns = transition.namespace;
+        deltaMap.get(ns)?.delete(s);
+    }
+    const computedAfter = toSnapshot(deltaMap);
+    const deepEqual = (a, b) => {
+        const keysA = Object.keys(a).sort();
+        const keysB = Object.keys(b).sort();
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const k of keysA) {
+            if (!b[k])
+                return false;
+            if (a[k].join(",") !== b[k].join(","))
+                return false;
+        }
+        return true;
+    };
+    if (!deepEqual(computedAfter, transition.statesAfter)) {
+        const msg = `[Invariant-1] Delta inconsistency in transition[${transition.actionIndex}] "${transition.function}": statesAfter mismatch`;
+        if (!isStrict()) {
+            console.error(msg);
+            return;
+        }
+        throw new ssg_validator_1.InvariantViolationError(msg, {
+            invariant: "delta-consistency",
+            namespace: transition.namespace,
+            function: transition.function,
+            index: transition.actionIndex,
+            expected: computedAfter,
+            actual: transition.statesAfter,
+        });
+    }
+}
+/** Assert rule hashes match — detects when validation rules changed under a ledger. */
+function assertRuleHashMatch(expected, actual, context) {
+    if (expected === actual)
+        return;
+    const msg = context
+        ? `Rule hash mismatch in ${context}: expected ${expected.slice(0, 16)}, got ${actual.slice(0, 16)}`
+        : `Rule hash mismatch: expected ${expected.slice(0, 16)}, got ${actual.slice(0, 16)}`;
+    if (!isStrict()) {
+        console.error(msg);
+        return;
+    }
+    throw new ssg_validator_1.InvariantViolationError(msg, {
+        invariant: "rule-hash-mismatch",
+    });
+}
+/** Assert transition indices are strictly monotonic (no duplicates, non-decreasing). */
+function assertTransitionOrder(ledger) {
+    if (ledger.length <= 1)
+        return;
+    for (let i = 1; i < ledger.length; i++) {
+        if (ledger[i].actionIndex <= ledger[i - 1].actionIndex) {
+            const msg = `[Transition Order] Non-monotonic indices at position ${i}: index[${i - 1}]=${ledger[i - 1].actionIndex}, index[${i}]=${ledger[i].actionIndex}`;
+            if (!isStrict()) {
+                console.error(msg);
+                return;
+            }
+            throw new ssg_validator_1.InvariantViolationError(msg, {
+                invariant: "transition-order",
+                index: i,
+            });
+        }
+    }
+}
+/** Convenience: run all invariant checks on a ledger. Does not throw if all pass. */
+function assertLedgerInvariants(ledger, namespaceInitialStates = (0, protocol_registry_1.getNsInit)(), expectedRuleHash) {
+    assertTransitionOrder(ledger);
+    assertLedgerConsistency(ledger, namespaceInitialStates);
+    for (const t of ledger) {
+        if (t.valid)
+            assertDeltaConsistency(t);
+    }
+    if (expectedRuleHash) {
+        const actualRuleHash = (0, ssg_validator_1.hashRules)(new Map()); // ledger's first transition carries ruleHash
+        const ledgerRuleHash = ledger[0]?.ruleHash;
+        if (ledgerRuleHash) {
+            assertRuleHashMatch(expectedRuleHash, ledgerRuleHash, "ledger invariants check");
+        }
+    }
+}