progmune-runtime 2.1.5 → 3.2.0

package/dist/topology-factory.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * P8.2: Topology Factory — programmatic protocol state machine generation
+ *
+ * Generates protocol rule sets for 10 distinct topology types,
+ * enabling diverse benchmark construction without hand-writing
+ * each protocol. Every topology is defined purely by its
+ * state transition structure — function names are auto-generated.
+ *
+ * 10 topologies:
+ *   T1  linear            A→B→C→D chain
+ *   T2  star              hub with radial spokes
+ *   T3  tree              branching decision tree
+ *   T4  loop              self-transition cycle with exit
+ *   T5  two_phase_commit  prepare → commit/rollback fork
+ *   T6  auth_bridge       auth gate → multiple resources
+ *   T7  nested            inner/outer resource dependency
+ *   T8  rollback          reversible forward/backward edges
+ *   T9  fan_out           fork-join parallelism
+ *   T10 stateless         self-loop only, no state change
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_TOPOLOGIES = void 0;
+exports.createProtocolForTopology = createProtocolForTopology;
+exports.ALL_TOPOLOGIES = [
+    "linear", "star", "tree", "loop", "two_phase_commit",
+    "auth_bridge", "nested", "rollback", "fan_out", "stateless",
+];
+/**
+ * Create protocol rules for a given topology type.
+ * Returns SSG-compatible StateAnnotation map.
+ */
+function createProtocolForTopology(type, numStates) {
+    const rules = buildRules(type, numStates);
+    const map = new Map();
+    // Convert ProtocolRule[] to Map<string, StateAnnotation>
+    // Group by action (function name) — each function appears once
+    const byAction = new Map();
+    for (const r of rules) {
+        if (!byAction.has(r.action)) {
+            byAction.set(r.action, { from: new Set(), to: new Set() });
+        }
+        byAction.get(r.action).from.add(r.from);
+        byAction.get(r.action).to.add(r.to);
+    }
+    for (const [action, { from, to }] of byAction) {
+        const postStates = [...to];
+        // Invalidation: states in "from" that are NOT in "to" for this action
+        // and NOT in "from" for any subsequent action that depends on them
+        const invalidate = [];
+        for (const f of from) {
+            // Check if any other action requires this state as a pre_state
+            let stillNeeded = false;
+            for (const [otherAction, otherEntry] of byAction) {
+                if (otherAction === action)
+                    continue; // skip self
+                if (otherEntry.from.has(f)) {
+                    stillNeeded = true;
+                    break;
+                }
+            }
+            if (!stillNeeded && !to.has(f)) {
+                invalidate.push(f);
+            }
+        }
+        map.set(action, {
+            pre_states: [...from],
+            post_states: postStates.length > 0 ? postStates : [],
+            invalidate: invalidate.length > 0 ? invalidate : undefined,
+            namespace: type,
+        });
+    }
+    return map;
+}
+function buildRules(type, n) {
+    switch (type) {
+        case "linear": return buildLinear(n || 4);
+        case "star": return buildStar();
+        case "tree": return buildTree(2, 2);
+        case "loop": return buildLoop();
+        case "two_phase_commit": return buildTwoPhaseCommit();
+        case "auth_bridge": return buildAuthBridge();
+        case "nested": return buildNested();
+        case "rollback": return buildRollback();
+        case "fan_out": return buildFanOut();
+        case "stateless": return buildStateless();
+    }
+}
+function buildLinear(n) {
+    const rules = [];
+    for (let i = 0; i < n; i++) {
+        const from = i === 0 ? "INIT" : `S${i - 1}`;
+        const to = i < n - 1 ? `S${i}` : `S${n - 1}_DONE`;
+        const action = i === 0 ? "open" : i === n - 1 ? "close" : `op${i}`;
+        rules.push({ from, to, action });
+    }
+    return rules;
+}
+function buildStar() {
+    return [
+        { from: "INIT", to: "HUB", action: "acquire" },
+        { from: "HUB", to: "LEAF1", action: "use_a" },
+        { from: "LEAF1", to: "HUB", action: "release_a" },
+        { from: "HUB", to: "LEAF2", action: "use_b" },
+        { from: "LEAF2", to: "HUB", action: "release_b" },
+        { from: "HUB", to: "LEAF3", action: "use_c" },
+        { from: "LEAF3", to: "HUB", action: "release_c" },
+        { from: "HUB", to: "DONE", action: "destroy" },
+    ];
+}
+function buildTree(branchFactor, depth) {
+    const rules = [];
+    rules.push({ from: "INIT", to: "ROOT", action: "enter" });
+    let nodeCount = 1;
+    const id = (d, b) => `N${d}_${b}`;
+    for (let d = 0; d < depth; d++) {
+        const nodesAtLevel = Math.pow(branchFactor, d);
+        for (let n = 0; n < nodesAtLevel; n++) {
+            for (let b = 0; b < branchFactor; b++) {
+                const child = nodeCount++;
+                rules.push({
+                    from: d === 0 && n === 0 ? "ROOT" : id(d, n),
+                    to: id(d + 1, child),
+                    action: `branch_d${d}_b${b}`,
+                });
+            }
+        }
+    }
+    return rules;
+}
+function buildLoop() {
+    return [
+        { from: "INIT", to: "LOOP", action: "init_loop" },
+        { from: "LOOP", to: "LOOP", action: "process" },
+        { from: "LOOP", to: "LOOP", action: "poll" },
+        { from: "LOOP", to: "EXIT", action: "exit_loop" },
+        { from: "LOOP", to: "EXIT", action: "timeout" },
+    ];
+}
+function buildTwoPhaseCommit() {
+    return [
+        { from: "INIT", to: "TX_ACTIVE", action: "begin_tx" },
+        { from: "TX_ACTIVE", to: "TX_ACTIVE", action: "insert" },
+        { from: "TX_ACTIVE", to: "TX_ACTIVE", action: "update" },
+        { from: "TX_ACTIVE", to: "PREPARED", action: "prepare" },
+        { from: "PREPARED", to: "COMMITTED", action: "commit" },
+        { from: "PREPARED", to: "ABORTED", action: "rollback" },
+    ];
+}
+function buildAuthBridge() {
+    return [
+        { from: "INIT", to: "AUTHED", action: "authenticate" },
+        { from: "AUTHED", to: "FILE_OPEN", action: "open_file" },
+        { from: "FILE_OPEN", to: "AUTHED", action: "close_file" },
+        { from: "AUTHED", to: "DB_OPEN", action: "connect_db" },
+        { from: "DB_OPEN", to: "AUTHED", action: "disconnect_db" },
+        { from: "AUTHED", to: "INIT", action: "logout" },
+    ];
+}
+function buildNested() {
+    return [
+        { from: "INIT", to: "OUTER_HELD", action: "acquire_outer" },
+        { from: "OUTER_HELD", to: "INNER_HELD", action: "acquire_inner" },
+        { from: "INNER_HELD", to: "OUTER_HELD", action: "release_inner" },
+        { from: "OUTER_HELD", to: "DONE", action: "release_outer" },
+    ];
+}
+function buildRollback() {
+    return [
+        { from: "INIT", to: "S1", action: "step1" },
+        { from: "S1", to: "S2", action: "step2" },
+        { from: "S2", to: "S3", action: "step3" },
+        { from: "S3", to: "DONE", action: "commit_all" },
+        { from: "S2", to: "S1", action: "undo_step2" },
+        { from: "S3", to: "S2", action: "undo_step3" },
+    ];
+}
+function buildFanOut() {
+    return [
+        { from: "INIT", to: "A", action: "fork_a" },
+        { from: "INIT", to: "B", action: "fork_b" },
+        { from: "INIT", to: "C", action: "fork_c" },
+        { from: "A", to: "JOIN", action: "op_a" },
+        { from: "B", to: "JOIN", action: "op_b" },
+        { from: "C", to: "JOIN", action: "op_c" },
+        { from: "JOIN", to: "DONE", action: "merge" },
+    ];
+}
+function buildStateless() {
+    return [
+        { from: "IDLE", to: "IDLE", action: "compute_hash" },
+        { from: "IDLE", to: "IDLE", action: "validate_input" },
+        { from: "IDLE", to: "IDLE", action: "encode_payload" },
+        { from: "IDLE", to: "IDLE", action: "decode_payload" },
+    ];
+}

package/dist/topology-representation.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * P7.2: Topology Representation — From Verb Learning to Structure Learning
+ *
+ * Replaces keyword-based clustering with graph topology analysis.
+ * Measures cross-repo similarity using PURE topology — no function names.
+ *
+ * Key insight from P7.1: 100% → 0% under name scrambling.
+ * The system must learn Acquire→Use→Release from graph structure,
+ * not from open/close/create vocabulary.
+ *
+ * Three levels:
+ *   L1: Transition matrix (directed edges)
+ *   L2: State machine (graph topology fingerprint)
+ *   L3: Role discovery (SOURCE/SINK/HUB)
+ *
+ * Semantic Adversarial Test: rename open→destroy, close→create.
+ * If topology similarity survives, it's real structure learning.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTopologyGraph = buildTopologyGraph;
+exports.fingerprintRepo = fingerprintRepo;
+exports.runTopologyExperiment = runTopologyExperiment;
+exports.printTopologyReport = printTopologyReport;
+const software_physics_1 = require("./experimental/software-physics");
+/** Build a topology graph from a call sequence. Node labels are opaque indices. */
+function buildTopologyGraph(sequence) {
+    const n = sequence.length;
+    if (n === 0) {
+        return { nodeCount: 0, edgeCount: 0, edges: [], inDegree: [], outDegree: [], sources: [], sinks: [], diameter: 0, isDAG: true };
+    }
+    const edges = [];
+    const inDegree = new Array(n).fill(0);
+    const outDegree = new Array(n).fill(0);
+    for (let i = 0; i < n - 1; i++) {
+        edges.push({ fromIdx: i, toIdx: i + 1 });
+        outDegree[i]++;
+        inDegree[i + 1]++;
+    }
+    const sources = [];
+    const sinks = [];
+    for (let i = 0; i < n; i++) {
+        if (inDegree[i] === 0)
+            sources.push(i);
+        if (outDegree[i] === 0)
+            sinks.push(i);
+    }
+    return {
+        nodeCount: n,
+        edgeCount: edges.length,
+        edges,
+        inDegree,
+        outDegree,
+        sources,
+        sinks,
+        diameter: n - 1, // linear chain
+        isDAG: true, // linear chain is always a DAG
+    };
+}
+/** Build a name-independent fingerprint from a set of sequences. */
+function fingerprintRepo(sequences) {
+    if (sequences.length === 0) {
+        return { nodeCount: 0, edgeCount: 0, sourceCount: 0, sinkCount: 0, avgOutDegree: 0, diameter: 0, isDAG: true, outDegreeDist: [] };
+    }
+    const graphs = sequences.map(buildTopologyGraph);
+    const totalNodes = graphs.reduce((s, g) => s + g.nodeCount, 0);
+    const totalEdges = graphs.reduce((s, g) => s + g.edgeCount, 0);
+    const totalSources = graphs.reduce((s, g) => s + g.sources.length, 0);
+    const totalSinks = graphs.reduce((s, g) => s + g.sinks.length, 0);
+    const avgOut = totalNodes > 0 ? totalEdges / totalNodes : 0;
+    const avgDiameter = graphs.reduce((s, g) => s + g.diameter, 0) / graphs.length;
+    const allDAG = graphs.every(g => g.isDAG);
+    // Out-degree distribution
+    const maxOut = Math.max(...graphs.map(g => Math.max(...g.outDegree, 0)), 0);
+    const dist = new Array(maxOut + 1).fill(0);
+    for (const g of graphs) {
+        for (const d of g.outDegree) {
+            if (d < dist.length)
+                dist[d]++;
+        }
+    }
+    return {
+        nodeCount: totalNodes,
+        edgeCount: totalEdges,
+        sourceCount: totalSources,
+        sinkCount: totalSinks,
+        avgOutDegree: avgOut,
+        diameter: avgDiameter,
+        isDAG: allDAG,
+        outDegreeDist: dist,
+    };
+}
+/**
+ * Compute topological similarity between two repos.
+ * Uses Jaccard on binned fingerprint features — ZERO function names.
+ */
+function topologySimilarity(a, b) {
+    // Normalize features to [0,1] bins
+    const features = [
+        a.nodeCount > 0 && b.nodeCount > 0 ? Math.min(a.nodeCount, b.nodeCount) / Math.max(a.nodeCount, b.nodeCount) : 0,
+        a.edgeCount > 0 && b.edgeCount > 0 ? Math.min(a.edgeCount, b.edgeCount) / Math.max(a.edgeCount, b.edgeCount) : 0,
+        a.sourceCount > 0 && b.sourceCount > 0 ? Math.min(a.sourceCount, b.sourceCount) / Math.max(a.sourceCount, b.sourceCount) : 0,
+        a.sinkCount > 0 && b.sinkCount > 0 ? Math.min(a.sinkCount, b.sinkCount) / Math.max(a.sinkCount, b.sinkCount) : 0,
+        Math.abs(a.avgOutDegree - b.avgOutDegree) < 0.5 ? 1 : 0,
+        a.diameter > 0 && b.diameter > 0 ? Math.min(a.diameter, b.diameter) / Math.max(a.diameter, b.diameter) : 0,
+        a.isDAG === b.isDAG ? 1 : 0,
+    ];
+    return features.reduce((s, f) => s + f, 0) / features.length;
+}
+/** Classify each node by its topological role (name-independent). */
+function roleProfile(graph) {
+    const n = graph.nodeCount;
+    if (n === 0)
+        return { sourceRatio: 0, sinkRatio: 0, hubRatio: 0, passThroughRatio: 0 };
+    let sources = 0, sinks = 0, hubs = 0, passThrough = 0;
+    for (let i = 0; i < n; i++) {
+        const inD = graph.inDegree[i];
+        const outD = graph.outDegree[i];
+        if (inD === 0 && outD === 0) { /* isolated */ }
+        else if (inD === 0)
+            sources++;
+        else if (outD === 0)
+            sinks++;
+        else if (outD >= 3)
+            hubs++;
+        else if (inD === 1 && outD === 1)
+            passThrough++;
+    }
+    return {
+        sourceRatio: sources / n,
+        sinkRatio: sinks / n,
+        hubRatio: hubs / n,
+        passThroughRatio: passThrough / n,
+    };
+}
+/** Compare two repos by their role profiles. */
+function roleSimilarity(a, b) {
+    const feats = [
+        1 - Math.abs(a.sourceRatio - b.sourceRatio),
+        1 - Math.abs(a.sinkRatio - b.sinkRatio),
+        1 - Math.abs(a.hubRatio - b.hubRatio),
+        1 - Math.abs(a.passThroughRatio - b.passThroughRatio),
+    ];
+    return feats.reduce((s, f) => s + Math.max(0, f), 0) / feats.length;
+}
+/**
+ * Run the topology representation experiment.
+ *
+ * The decisive test: measure cross-repo similarity using ONLY graph topology,
+ * with function names completely removed and replaced by opaque indices.
+ */
+function runTopologyExperiment() {
+    // Baseline: name-based
+    const redisSeqs = software_physics_1.KNOWN_REPO_SIGNATURES["Redis"].map(fn => [fn]); // wrap as single-fn sequences
+    const sqliteSeqs = software_physics_1.KNOWN_REPO_SIGNATURES["SQLite"].map(fn => [fn]);
+    const redisFp = fingerprintRepo(CROSS_REPO_SEQS("Redis"));
+    const sqliteFp = fingerprintRepo(CROSS_REPO_SEQS("SQLite"));
+    const topologyOnly = topologySimilarity(redisFp, sqliteFp);
+    // Role-based
+    const redisGraphs = CROSS_REPO_SEQS("Redis").map(buildTopologyGraph);
+    const sqliteGraphs = CROSS_REPO_SEQS("SQLite").map(buildTopologyGraph);
+    const redisRole = redisGraphs.reduce((acc, g) => {
+        const r = roleProfile(g);
+        acc.sourceRatio += r.sourceRatio;
+        acc.sinkRatio += r.sinkRatio;
+        acc.hubRatio += r.hubRatio;
+        acc.passThroughRatio += r.passThroughRatio;
+        return acc;
+    }, { sourceRatio: 0, sinkRatio: 0, hubRatio: 0, passThroughRatio: 0 });
+    const sqliteRole = sqliteGraphs.reduce((acc, g) => {
+        const r = roleProfile(g);
+        acc.sourceRatio += r.sourceRatio;
+        acc.sinkRatio += r.sinkRatio;
+        acc.hubRatio += r.hubRatio;
+        acc.passThroughRatio += r.passThroughRatio;
+        return acc;
+    }, { sourceRatio: 0, sinkRatio: 0, hubRatio: 0, passThroughRatio: 0 });
+    const n = Math.max(1, redisGraphs.length);
+    const m = Math.max(1, sqliteGraphs.length);
+    redisRole.sourceRatio /= n;
+    redisRole.sinkRatio /= n;
+    redisRole.hubRatio /= n;
+    redisRole.passThroughRatio /= n;
+    sqliteRole.sourceRatio /= m;
+    sqliteRole.sinkRatio /= m;
+    sqliteRole.hubRatio /= m;
+    sqliteRole.passThroughRatio /= m;
+    const roleSimilarityScore = roleSimilarity(redisRole, sqliteRole);
+    // Semantic adversarial: rename open→destroy, close→create (misleading names, topology unchanged)
+    // Use the same sequences but with scrambled names (F_001 format)
+    const scrambledRedis = CROSS_REPO_SEQS("Redis").map(seq => seq.map((_, i) => `F_${String(i).padStart(4, "0")}`));
+    const scrambledSqlite = CROSS_REPO_SEQS("SQLite").map(seq => seq.map((_, i) => `X_${String(i).padStart(4, "0")}`));
+    const scrambledRedisFp = fingerprintRepo(scrambledRedis);
+    const scrambledSqliteFp = fingerprintRepo(scrambledSqlite);
+    const semanticAdversarial = topologySimilarity(scrambledRedisFp, scrambledSqliteFp);
+    // Baseline from P6.2 (with names)
+    const redisA = (0, software_physics_1.analyzeRepoPhysics)("Redis", software_physics_1.KNOWN_REPO_SIGNATURES["Redis"]);
+    const sqliteA = (0, software_physics_1.analyzeRepoPhysics)("SQLite", software_physics_1.KNOWN_REPO_SIGNATURES["SQLite"]);
+    const baseline = (0, software_physics_1.compareRepoPhysics)(redisA, sqliteA).similarity;
+    const survivalRate = baseline > 0 ? topologyOnly / baseline : 0;
+    return {
+        baseline,
+        topologyOnly,
+        roleSimilarity: roleSimilarityScore,
+        semanticAdversarial,
+        topologySurvivalRate: survivalRate,
+        verdict: survivalRate > 0.7 ? "structure_learned" :
+            survivalRate < 0.2 ? "verb_learning" : "partial",
+    };
+}
+/** Helper: get sequences from a known repo. */
+function CROSS_REPO_SEQS(repo) {
+    const all = {
+        Redis: [["createClient", "sendCommand", "closeClient"], ["selectDB", "getKey"], ["createClient", "sendCommand", "readReply", "closeClient"]],
+        SQLite: [["sqlite3_open", "sqlite3_exec", "sqlite3_close"], ["sqlite3_prepare", "sqlite3_step", "sqlite3_finalize"], ["sqlite3_open", "sqlite3_prepare", "sqlite3_step", "sqlite3_finalize", "sqlite3_close"]],
+    };
+    return all[repo] || [];
+}
+function printTopologyReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P7.2 Topology Representation Experiment          ║");
+    console.log("║   Pure graph structure — ZERO function names       ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Baseline (name-based):        ${(report.baseline * 100).toFixed(0)}%`);
+    console.log(`Topology Only (no names):     ${(report.topologyOnly * 100).toFixed(0)}%`);
+    console.log(`Role Similarity:              ${(report.roleSimilarity * 100).toFixed(0)}%`);
+    console.log(`Semantic Adversarial:         ${(report.semanticAdversarial * 100).toFixed(0)}%`);
+    console.log(`Topology Survival Rate:       ${(report.topologySurvivalRate * 100).toFixed(0)}%`);
+    console.log();
+    console.log(`─── Verdict ───`);
+    console.log(`  Classification: ${report.verdict.toUpperCase()}`);
+    console.log();
+    if (report.verdict === "structure_learned") {
+        console.log("  ✅ Topology similarity SURVIVES without function names.");
+        console.log("     The system genuinely learns protocol STRUCTURE.");
+    }
+    else if (report.verdict === "verb_learning") {
+        console.log("  ❌ Topology similarity COLLAPSES without function names.");
+        console.log("     The system depends on API vocabulary, not graph structure.");
+    }
+    console.log();
+}

package/dist/topology-representation.test.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * P7.2: Topology Representation Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const topology_representation_1 = require("./topology-representation");
+(0, vitest_1.describe)("Topology Graph", () => {
+    (0, vitest_1.it)("builds DAG from linear sequence", () => {
+        const g = (0, topology_representation_1.buildTopologyGraph)(["A", "B", "C"]);
+        (0, vitest_1.expect)(g.nodeCount).toBe(3);
+        (0, vitest_1.expect)(g.edgeCount).toBe(2);
+        (0, vitest_1.expect)(g.sources.length).toBe(1); // A: in=0
+        (0, vitest_1.expect)(g.sinks.length).toBe(1); // C: out=0
+        (0, vitest_1.expect)(g.isDAG).toBe(true);
+        (0, vitest_1.expect)(g.diameter).toBe(2);
+    });
+});
+(0, vitest_1.describe)("P7.2 Topology Experiment", () => {
+    (0, vitest_1.it)("measures cross-repo similarity with pure topology (no names)", () => {
+        const report = (0, topology_representation_1.runTopologyExperiment)();
+        (0, vitest_1.expect)(report.baseline).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.topologyOnly).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(report.topologyOnly).toBeLessThanOrEqual(1);
+        (0, topology_representation_1.printTopologyReport)(report);
+    });
+});