progmune-runtime 2.1.5 → 3.2.0

package/dist/python-emitter.js

@@ -35,37 +35,48 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitPython = emitPython;
 const fs = __importStar(require("fs"));
+const BASIC_TYPES = new Set([
+    "str", "int", "float", "bool", "list", "dict", "tuple", "bytes",
+    "string", "number", "boolean", "any", "void", "None",
+]);
 function toPythonModule(filePath) {
     let module = filePath.replace(/\.py$/, "").replace(/\//g, ".");
     module = module.replace(/\.$/, "").replace(/\.__init__$/, "");
     return module;
 }
 function pythonValue(val) {
-    if (typeof val === 'string')
+    if (typeof val === "string")
         return JSON.stringify(val);
-    if (typeof val === 'number' || typeof val === 'boolean')
+    if (typeof val === "number" || typeof val === "boolean")
         return String(val);
     if (val === null || val === undefined)
-        return 'None';
-    if (typeof val === 'object') {
+        return "None";
+    if (typeof val === "object") {
         const entries = Object.entries(val).map(([k, v]) => `${JSON.stringify(k)}: ${pythonValue(v)}`);
-        return `{${entries.join(', ')}}`;
+        return `{${entries.join(", ")}}`;
     }
-    return 'None';
+    return "None";
 }
-function emitPython(actions) {
-    const ir = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+const STRING_ENUMS = {
+    SVL: '"SVL-4"', RootCause: '"F01"', BranchReason: '"repair_attempt"',
+    RepairStrategy: '"insert"', ConstraintType: '"protocol"',
+};
+function emitPython(actions, meta) {
+    const irRaw = JSON.parse(fs.readFileSync("ir.json", "utf-8"));
+    const ir = irRaw.functions || irRaw;
     const funcToFile = new Map();
-    const funcToParams = new Map();
+    const fnMeta = new Map();
     for (const f of ir) {
         funcToFile.set(f.name, f.file);
-        funcToParams.set(f.name, f.params || []);
+        fnMeta.set(f.name, f);
     }
+    // ── Collect imports ──
     const imports = new Map();
     const collectImports = (action) => {
         if (action.kind === "call" && action.function) {
             const file = funcToFile.get(action.function);
-            if (file) {
+            const meta = fnMeta.get(action.function);
+            if (file && file !== "(external)" && meta?.exported !== false) {
                 const mod = toPythonModule(file);
                 if (!imports.has(mod))
                     imports.set(mod, new Set());
@@ -76,74 +87,181 @@ function emitPython(actions) {
             (action.thenActions || []).forEach(collectImports);
             (action.elseActions || []).forEach(collectImports);
         }
+        else if (action.kind === "for") {
+            (action.bodyActions || []).forEach(collectImports);
+        }
     };
     for (const a of actions)
         collectImports(a);
+    // ── Variable flow: scan all actions to find inputs ──
+    const declared = new Set();
+    const referenced = new Set();
+    const scanAction = (action) => {
+        if (action.kind === "call" && action.assignTo)
+            declared.add(action.assignTo);
+        else if (action.kind === "assign" && action.target)
+            declared.add(action.target);
+        else if (action.kind === "for" && action.variable)
+            declared.add(action.variable);
+        if (action.kind === "call" && action.args) {
+            for (const arg of action.args) {
+                const v = typeof arg === "object" ? arg?.value : arg;
+                if (typeof v === "string" && /^[a-zA-Z_]\w*$/.test(v) && v !== "")
+                    referenced.add(v);
+            }
+        }
+        if (action.kind === "if") {
+            (action.thenActions || []).forEach(scanAction);
+            (action.elseActions || []).forEach(scanAction);
+        }
+        else if (action.kind === "for") {
+            (action.bodyActions || []).forEach(scanAction);
+        }
+    };
+    for (const action of actions)
+        scanAction(action);
+    const rawInputs = [...referenced].filter(v => !declared.has(v) && v !== "");
+    // Resolve types from args
+    const inputTypes = new Map();
+    for (const action of actions) {
+        if (action.kind === "call" && action.args) {
+            for (const arg of action.args) {
+                const v = typeof arg === "object" ? arg?.value : arg;
+                const t = typeof arg === "object" ? arg?.type : "str";
+                if (typeof v === "string" && rawInputs.includes(v))
+                    inputTypes.set(v, t);
+            }
+        }
+    }
+    // ── Parameter bloat guard ──
+    const MAX_PARAMS = 10;
+    if (rawInputs.length > MAX_PARAMS) {
+        return `# REFINEMENT_NEEDED: ${rawInputs.length} params detected (max ${MAX_PARAMS}). Split into smaller functions.`;
+    }
+    // ── Build code ──
     let code = "";
+    // Generation marker
+    if (meta?.sessionId) {
+        code += `# @progmune-generated session=${meta.sessionId} timestamp=${new Date().toISOString()}`;
+        if (meta.ruleHash)
+            code += ` ruleHash=${meta.ruleHash}`;
+        code += "\n";
+        const funcs = meta.irFunctionCount ?? ir.length;
+        const rules = meta.protocolRuleCount ?? 0;
+        code += `# Generated with IR constraint: ${funcs} functions`;
+        if (rules > 0)
+            code += `, ${rules} protocol rules`;
+        code += "\n";
+    }
     for (const [mod, funcs] of imports) {
         code += `from ${mod} import ${Array.from(funcs).join(", ")}\n`;
     }
-    code += "\n\ndef main():\n";
-    // 使用全局变量跟踪已声明的变量
-    const declaredVars = new Set();
-    const argToPython = (val) => {
-        if (typeof val === 'string') {
-            if (declaredVars.has(val))
-                return val;
-            return JSON.stringify(val);
+    const paramList = rawInputs.map(v => `${v}: ${inputTypes.get(v) || "str"}`).join(", ");
+    code += `\n\ndef main(${paramList}):\n`;
+    const argToPython = (action, i, a, meta) => {
+        const paramType = meta?.params?.[i]?.type || "str";
+        const val = a?.value;
+        // Variable reference
+        if (typeof val === "string" && declared.has(val))
+            return val;
+        if (typeof val === "string" && /^[a-zA-Z_]\w*$/.test(val) && val !== "")
+            return val;
+        // Empty default → use parameter name
+        const isEmpty = (v) => v === "" || v === 0 || v === false || v === null;
+        if (isEmpty(val) && a?.name) {
+            if (rawInputs.includes(a.name)) {
+                declared.add(a.name);
+                return a.name;
+            }
         }
+        // String enums
+        if (STRING_ENUMS[paramType])
+            return STRING_ENUMS[paramType];
+        // Basic type defaults
+        if (paramType === "string" || paramType === "str")
+            return '""';
+        if (paramType === "number" || paramType === "int" || paramType === "float")
+            return "0";
+        if (paramType === "boolean" || paramType === "bool")
+            return "False";
+        if (paramType.endsWith("[]") || paramType === "list")
+            return "[]";
+        if (paramType.startsWith("Map<") || paramType === "dict")
+            return "{}";
+        if (paramType.startsWith("Set<"))
+            return "set()";
         return pythonValue(val);
     };
-    // 转换为 Python 代码行，使用数字缩进级别以确保一致性
+    let counter = 0;
     const convertLines = (action, indentLevel) => {
         const indent = "    ".repeat(indentLevel);
         if (!action || !action.kind)
             return [];
         if (action.kind === "call") {
-            const fname = action.function || "unknown";
-            const args = (action.args || []).map((a) => argToPython(a.value)).join(", ");
-            const resultVar = action.assignTo || `_res`;
-            declaredVars.add(resultVar);
-            return [`${indent}${resultVar} = ${fname}(${args})`];
+            const meta = fnMeta.get(action.function || "");
+            const args = (action.args || []).map((a, i) => argToPython(action, i, a, meta)).join(", ");
+            const resultVar = action.assignTo || `_res${counter++}`;
+            declared.add(resultVar);
+            return [`${indent}${resultVar} = ${action.function}(${args})`];
         }
         if (action.kind === "if") {
-            const lines = [];
-            lines.push(`${indent}if ${action.condition}:`);
-            const thenActions = action.thenActions || [];
-            const elseActions = action.elseActions || [];
-            if (thenActions.length > 0) {
-                for (const a of thenActions) {
+            const lines = [`${indent}if ${action.condition}:`];
+            if ((action.thenActions || []).length > 0) {
+                for (const a of action.thenActions)
                     lines.push(...convertLines(a, indentLevel + 1));
-                }
             }
             else {
-                // 防止空块
                 lines.push(`${indent}    pass`);
             }
-            if (elseActions.length > 0) {
+            if ((action.elseActions || []).length > 0) {
                 lines.push(`${indent}else:`);
-                for (const a of elseActions) {
+                for (const a of action.elseActions)
                     lines.push(...convertLines(a, indentLevel + 1));
-                }
             }
             return lines;
         }
+        if (action.kind === "for") {
+            declared.add(action.variable);
+            const lines = [`${indent}for ${action.variable} in ${action.iterable}:`];
+            for (const a of (action.bodyActions || []))
+                lines.push(...convertLines(a, indentLevel + 1));
+            return lines;
+        }
+        if (action.kind === "assign") {
+            const val = typeof action.value === "string"
+                ? (declared.has(action.value) ? action.value : JSON.stringify(action.value))
+                : pythonValue(action.value);
+            if (action.target)
+                declared.add(action.target);
+            return [`${indent}${action.target} = ${val}`];
+        }
         if (action.kind === "return") {
-            const val = action.value;
-            if (typeof val === 'string') {
-                if (declaredVars.has(val))
-                    return [`${indent}return ${val}`];
-                return [`${indent}return ${JSON.stringify(val)}`];
+            if (typeof action.value === "string") {
+                if (declared.has(action.value))
+                    return [`${indent}return ${action.value}`];
+                return [`${indent}return ${JSON.stringify(action.value)}`];
             }
-            return [`${indent}return ${pythonValue(val)}`];
+            return [`${indent}return ${pythonValue(action.value)}`];
         }
         return [];
     };
     const lines = [];
-    for (const a of actions) {
+    for (const a of actions)
         lines.push(...convertLines(a, 1));
-    }
     code += lines.join("\n") + "\n";
-    code += "\nif __name__ == '__main__':\n    main()\n";
+    // Auto-return injection: if LLM forgot to return
+    const lastAction = actions[actions.length - 1];
+    if (lastAction && lastAction.kind !== "return") {
+        const allCalls = actions.filter(a => a.kind === "call" && a.assignTo);
+        if (allCalls.length === 1) {
+            const c = allCalls[0];
+            code += `    return ${c.assignTo}\n`;
+        }
+        else if (allCalls.length > 1) {
+            const vars = allCalls.map(c => c.assignTo).join(", ");
+            code += `    return { ${vars} }\n`;
+        }
+    }
+    code += `\nif __name__ == "__main__":\n    main()\n`;
     return code;
 }

package/dist/python-protocol-extractor.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * P8.3: Python Protocol Extractor
+ *
+ * Extracts protocol state machines from Python IR by analyzing call
+ * sequences and decorator-based protocol annotations. Bridges the
+ * gap between Python IR (tools/extract_ir.py) and the Progmune
+ * protocol discovery pipeline (P6).
+ *
+ * Two modes:
+ *   1. Annotation-based: reads @progmune decorators from IR
+ *   2. Sequence-based: infers protocol from call co-occurrence patterns
+ *
+ * Both modes produce SSG-compatible StateAnnotation maps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractProtocolFromAnnotations = extractProtocolFromAnnotations;
+exports.extractCallSequencesFromIR = extractCallSequencesFromIR;
+exports.inferProtocolFromSequences = inferProtocolFromSequences;
+exports.discoverPythonProtocols = discoverPythonProtocols;
+exports.printPythonDiscoveryResult = printPythonDiscoveryResult;
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+// ═══════════════════════════════════════════════════════════════
+// Annotation-based extraction
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Extract protocol rules from Python IR using @progmune decorators.
+ *
+ * Each Python function with a @progmune decorator becomes a protocol
+ * rule with pre_states, post_states, and optional invalidate states.
+ */
+function extractProtocolFromAnnotations(ir) {
+    const rules = new Map();
+    for (const fn of ir) {
+        const proto = fn.protocol;
+        if (!proto)
+            continue;
+        const pre_states = Array.isArray(proto.pre_states) ? proto.pre_states : [];
+        const post_states = Array.isArray(proto.post_states) ? proto.post_states : [];
+        const invRaw = proto.invalidate;
+        const invalidate = Array.isArray(invRaw) && invRaw.length > 0
+            ? invRaw : undefined;
+        rules.set(fn.name, {
+            pre_states,
+            post_states,
+            invalidate,
+            namespace: proto.namespace || "python",
+        });
+    }
+    return rules;
+}
+// ═══════════════════════════════════════════════════════════════
+// Sequence-based inference
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Extract call sequences from Python IR.
+ *
+ * Builds ordered sequences of function calls by analyzing the call
+ * graph. For each function that calls others, the called functions
+ * form a sequence in source order (approximated by IR order).
+ */
+function extractCallSequencesFromIR(ir) {
+    const sequences = [];
+    // Method 1: Functions that call other functions form natural sequences
+    for (const fn of ir) {
+        const calls = fn.calls || [];
+        if (calls.length >= 2) {
+            sequences.push([...calls]);
+        }
+    }
+    // Method 2: Build sequences from cross-function call patterns
+    // If fnA calls fnB and fnB calls fnC, we get [fnB, fnC]
+    const fnMap = new Map();
+    for (const fn of ir)
+        fnMap.set(fn.name, fn);
+    // Build adjacency: which functions are called by which
+    const calledBy = new Map();
+    for (const fn of ir) {
+        for (const call of (fn.calls || [])) {
+            if (!calledBy.has(call))
+                calledBy.set(call, []);
+            calledBy.get(call).push(fn.name);
+        }
+    }
+    // Method 3: Topological sort of call graph
+    // Functions with no callers = entry points → follow call chain
+    const entryPoints = ir.filter(fn => !calledBy.has(fn.name) || calledBy.get(fn.name).length === 0);
+    for (const entry of entryPoints) {
+        const seq = [entry.name];
+        const visited = new Set([entry.name]);
+        let current = entry;
+        // Follow calls until we hit a function that calls nothing new
+        for (let depth = 0; depth < 10; depth++) {
+            const next = (current.calls || []).find(c => !visited.has(c) && fnMap.has(c));
+            if (!next)
+                break;
+            seq.push(next);
+            visited.add(next);
+            current = fnMap.get(next);
+        }
+        if (seq.length >= 2)
+            sequences.push(seq);
+    }
+    return sequences;
+}
+/**
+ * Infer protocol rules from call sequences using the auto-protocol-synthesizer.
+ */
+function inferProtocolFromSequences(sequences) {
+    const synthesized = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(sequences);
+    const rules = new Map();
+    for (const proto of synthesized) {
+        for (const r of proto.rules) {
+            rules.set(r.function, {
+                pre_states: r.pre_states,
+                post_states: r.post_states,
+                invalidate: r.invalidate,
+                namespace: "python_inferred",
+            });
+        }
+    }
+    return rules;
+}
+/**
+ * Run the full Python protocol discovery pipeline on a set of IR functions.
+ *
+ * 1. Extract protocol annotations from @progmune decorators
+ * 2. Extract call sequences from the call graph
+ * 3. Infer additional protocols from call sequences
+ * 4. Merge annotation and inferred rules
+ */
+function discoverPythonProtocols(ir) {
+    // 1. Annotation-based
+    const annotationRules = extractProtocolFromAnnotations(ir);
+    const annotationCount = annotationRules.size;
+    // 2. Sequence extraction
+    const callSequences = extractCallSequencesFromIR(ir);
+    const sequenceCount = callSequences.length;
+    // 3. Inference-based
+    const inferredRules = inferProtocolFromSequences(callSequences);
+    const inferredCount = inferredRules.size;
+    // 4. Merge (annotation rules take precedence)
+    const combinedRules = new Map(inferredRules);
+    for (const [fn, rule] of annotationRules) {
+        combinedRules.set(fn, rule);
+    }
+    return {
+        annotationRules,
+        annotationCount,
+        callSequences,
+        sequenceCount,
+        inferredRules,
+        inferredCount,
+        combinedRules,
+    };
+}
+function printPythonDiscoveryResult(result) {
+    console.log("\n─── Python Protocol Discovery ───");
+    console.log(`  Annotation rules:  ${result.annotationCount}`);
+    console.log(`  Call sequences:    ${result.sequenceCount}`);
+    console.log(`  Inferred rules:    ${result.inferredCount}`);
+    console.log(`  Combined rules:    ${result.combinedRules.size}`);
+    console.log();
+    if (result.annotationCount > 0) {
+        console.log("  ── Annotation-based protocols ──");
+        for (const [fn, rule] of result.annotationRules) {
+            const inv = rule.invalidate ? ` [inv: ${rule.invalidate.join(",")}]` : "";
+            console.log(`    ${fn}: [${rule.pre_states.join(",")}] → [${rule.post_states.join(",")}]${inv} (${rule.namespace})`);
+        }
+        console.log();
+    }
+    if (result.sequenceCount > 0) {
+        console.log("  ── Top call sequences ──");
+        for (const seq of result.callSequences.slice(0, 10)) {
+            console.log(`    ${seq.join(" → ")}`);
+        }
+        console.log();
+    }
+    if (result.inferredCount > 0) {
+        console.log("  ── Inferred protocols ──");
+        for (const [fn, rule] of result.inferredRules) {
+            const inv = rule.invalidate ? ` [inv: ${rule.invalidate.join(",")}]` : "";
+            console.log(`    ${fn}: [${rule.pre_states.join(",")}] → [${rule.post_states.join(",")}]${inv}`);
+        }
+        console.log();
+    }
+}

package/dist/python-protocol-extractor.test.js

@@ -0,0 +1,116 @@
+"use strict";
+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 });
+/**
+ * P8.3: Python Protocol Discovery — End-to-End Tests
+ *
+ * Verifies the full pipeline from Python IR extraction through
+ * protocol annotation parsing to SSG-compatible rule generation.
+ */
+const vitest_1 = require("vitest");
+const path = __importStar(require("path"));
+const extract_ir_python_1 = require("./extract-ir-python");
+const python_protocol_extractor_1 = require("./python-protocol-extractor");
+const state_machine_fingerprint_1 = require("./state-machine-fingerprint");
+const topology_factory_1 = require("./topology-factory");
+const PYTHON_FIXTURE = path.resolve(__dirname, "..", "test-python-protocol");
+(0, vitest_1.describe)("Python Protocol Discovery Pipeline", () => {
+    (0, vitest_1.it)("extracts IR from Python project with protocol annotations", () => {
+        const ir = (0, extract_ir_python_1.extractIRPython)(PYTHON_FIXTURE);
+        (0, vitest_1.expect)(ir.length).toBeGreaterThanOrEqual(8);
+        // Verify FunctionInfo-compatible output
+        for (const fn of ir) {
+            (0, vitest_1.expect)(fn.name).toBeTruthy();
+            (0, vitest_1.expect)(Array.isArray(fn.params)).toBe(true);
+            (0, vitest_1.expect)(Array.isArray(fn.calls)).toBe(true);
+            (0, vitest_1.expect)(typeof fn.exported).toBe("boolean");
+            (0, vitest_1.expect)(typeof fn.file).toBe("string");
+        }
+    });
+    (0, vitest_1.it)("extracts protocol annotations from @progmune decorators", () => {
+        const ir = (0, extract_ir_python_1.extractIRPython)(PYTHON_FIXTURE);
+        const rules = (0, python_protocol_extractor_1.extractProtocolFromAnnotations)(ir);
+        // Should find all 8 annotated functions
+        (0, vitest_1.expect)(rules.size).toBeGreaterThanOrEqual(8);
+        // Auth protocol
+        (0, vitest_1.expect)(rules.has("verify_password")).toBe(true);
+        (0, vitest_1.expect)(rules.get("verify_password").namespace).toBe("auth");
+        (0, vitest_1.expect)(rules.get("verify_password").pre_states).toEqual(["UNAUTHENTICATED"]);
+        (0, vitest_1.expect)(rules.get("verify_password").post_states).toEqual(["PASSWORD_VERIFIED"]);
+        // generate_jwt has invalidate
+        (0, vitest_1.expect)(rules.has("generate_jwt")).toBe(true);
+        (0, vitest_1.expect)(rules.get("generate_jwt").invalidate).toEqual(["PASSWORD_VERIFIED"]);
+        // File protocol
+        (0, vitest_1.expect)(rules.has("open_config")).toBe(true);
+        (0, vitest_1.expect)(rules.get("open_config").namespace).toBe("file");
+        // Stateless functions should NOT have protocol rules
+        (0, vitest_1.expect)(rules.has("compute_hash")).toBe(false);
+        (0, vitest_1.expect)(rules.has("validate_input")).toBe(false);
+    });
+    (0, vitest_1.it)("extracts call sequences from Python call graph", () => {
+        const ir = (0, extract_ir_python_1.extractIRPython)(PYTHON_FIXTURE);
+        const sequences = (0, python_protocol_extractor_1.extractCallSequencesFromIR)(ir);
+        (0, vitest_1.expect)(sequences.length).toBeGreaterThan(0);
+        // authenticate_and_open calls: verify_password, create_session, open_config,
+        //   read_config, close_config, logout
+        const crossSeq = sequences.find(s => s.includes("open_config"));
+        (0, vitest_1.expect)(crossSeq).toBeTruthy();
+    });
+    (0, vitest_1.it)("runs full discovery pipeline and produces combined rules", () => {
+        const ir = (0, extract_ir_python_1.extractIRPython)(PYTHON_FIXTURE);
+        const result = (0, python_protocol_extractor_1.discoverPythonProtocols)(ir);
+        (0, python_protocol_extractor_1.printPythonDiscoveryResult)(result);
+        // Annotation rules
+        (0, vitest_1.expect)(result.annotationCount).toBeGreaterThanOrEqual(8);
+        // Call sequences
+        (0, vitest_1.expect)(result.sequenceCount).toBeGreaterThan(0);
+        // Combined rules should contain all annotation rules
+        (0, vitest_1.expect)(result.combinedRules.size).toBeGreaterThanOrEqual(result.annotationCount);
+        for (const [fn, rule] of result.annotationRules) {
+            (0, vitest_1.expect)(result.combinedRules.has(fn)).toBe(true);
+        }
+    });
+    (0, vitest_1.it)("Python protocol state machine matches hand-written TypeScript equivalent", () => {
+        const ir = (0, extract_ir_python_1.extractIRPython)(PYTHON_FIXTURE);
+        const pythonRules = (0, python_protocol_extractor_1.extractProtocolFromAnnotations)(ir);
+        // Build TypeScript-equivalent auth protocol using topology factory
+        const tsAuthRules = (0, topology_factory_1.createProtocolForTopology)("linear", 4); // has similar shape
+        const pythonFp = (0, state_machine_fingerprint_1.extractStateMachine)(pythonRules);
+        const tsFp = (0, state_machine_fingerprint_1.extractStateMachine)(tsAuthRules);
+        const comp = (0, state_machine_fingerprint_1.compareStateMachines)(pythonFp, tsFp);
+        console.log(`\n  Python auth ↔ TypeScript linear: ${(comp.similarity * 100).toFixed(0)}%`);
+        (0, vitest_1.expect)(comp.similarity).toBeGreaterThan(0);
+    });
+});