progmune-runtime 2.0.4 → 2.1.0

package/dist/svl-distribution.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343822181_r90g9 timestamp=2026-06-01T19:57:03.488Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 394 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const genome = (0, failure_corpus_1.getFailureGenome)();
+    return genome;
+}
+main();

package/dist/terminal-status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780207842282_uihp3 timestamp=2026-05-31T06:10:44.349Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 306 functions, 17 protocol rules
+const semantic_trace_1 = require("./src/semantic-trace");
+function main() {
+    const summary = (0, semantic_trace_1.formatImmuneResponse)({});
+    return summary;
+}
+main();

package/dist/test_failure_corpus.js

@@ -9,7 +9,9 @@ const failure_corpus_1 = require("./failure-corpus");
     constraintType: "protocol",
     actionSequence: [{ kind: "call", function: "generate_jwt" }],
     errorDetail: "非法调用：generate_jwt 要求前置状态 [AUTHENTICATED]，当前状态为 [UNAUTHENTICATED]",
-    ssgState: "UNAUTHENTICATED",
+    ssgState: ["UNAUTHENTICATED"],
+    plannerAttempt: 1,
+    plannerRetryTotal: 3,
 });
 // 打印当前统计
 console.log("当前失败案例总数:", (0, failure_corpus_1.getAllFailures)().length);

package/dist/token-savings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343649325_e8j9k timestamp=2026-06-01T19:54:10.484Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 390 functions, 17 protocol rules
+const failure_corpus_1 = require("./failure-corpus");
+function main() {
+    const stats = (0, failure_corpus_1.getAntibodyStats)();
+    return stats;
+}
+main();

package/dist/total-repairs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343904555_v2jom timestamp=2026-06-01T19:58:26.164Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 397 functions, 17 protocol rules
+const execute_1 = require("./execute");
+function main() {
+    const metrics = (0, execute_1.getExecutionMetrics)();
+    const totalRepairCount = findIndex();
+    return totalRepairCount;
+}
+main();

package/dist/unresolved-count.js

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

package/dist/valid-fingerprints.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343878763_2tpv3 timestamp=2026-06-01T19:58:00.794Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 396 functions, 17 protocol rules
+const immune_reporter_1 = require("./immune-reporter");
+const ledger_registry_1 = require("./ledger-registry");
+function main() {
+    const fps = (0, immune_reporter_1.extractFingerprints)({});
+    const summary = (0, ledger_registry_1.verifyAllFingerprints)("defaultStr");
+    return summary;
+}
+main();

package/dist/validator.js

@@ -41,7 +41,8 @@ function loadIR() {
     const irPath = path.resolve(__dirname, "../ir.json");
     if (!fs.existsSync(irPath))
         return [];
-    return JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    return Array.isArray(raw) ? raw : (raw.functions || []);
 }
 const BUILTIN_WHITELIST = new Set([
     "console.log", "setTimeout", "setInterval", "clearTimeout",
@@ -69,128 +70,183 @@ function normalizeType(type) {
         return "any";
     return t;
 }
+// ========== 重写的变量流向分析：基于声明追踪的确定性检查 ==========
 function checkVariableFlow(actions) {
     const errors = [];
     const declared = new Map();
-    for (let i = 0; i < actions.length; i++) {
-        const action = actions[i];
+    const isLiteral = (val) => {
+        if (typeof val !== 'string')
+            return true;
+        if (/^["'`]/.test(val) || /["'`]$/.test(val))
+            return true;
+        if (/^\d+$/.test(val))
+            return true;
+        if (val === 'true' || val === 'false' || val === 'null' || val === 'undefined')
+            return true;
+        if (/\s/.test(val) || /[^\w]/.test(val))
+            return true;
+        return false;
+    };
+    const processAction = (action) => {
         if (action.kind === "call") {
-            for (const arg of (action.args || [])) {
-                if (typeof arg.value === "string" && /^[a-zA-Z_]\w*$/.test(arg.value)) {
-                    if (declared.has(arg.value))
-                        continue;
-                    if (arg.value.length < 15 && arg.value[0] === arg.value[0].toLowerCase()) {
-                        continue;
-                    }
-                }
-            }
+            // call 动作的参数值来自结构化 {name, type, value}，都是字面量，不做变量引用检查
             if (action.assignTo) {
-                if (action.args?.some(a => a.value === action.assignTo)) {
-                    errors.push(`变量 '${action.assignTo}' 在动作${i}中引用自身`);
-                }
                 declared.set(action.assignTo, "any");
             }
         }
         else if (action.kind === "assign") {
-            if (action.target) {
-                if (typeof action.value === "string" && /^[a-zA-Z_]\w*$/.test(action.value)) {
-                    if (!declared.has(action.value) && action.value.length < 15)
-                        continue;
-                    if (!declared.has(action.value))
-                        errors.push(`赋值时引用未定义变量 '${action.value}'`);
+            if (typeof action.value === "string") {
+                const val = action.value;
+                if (!isLiteral(val) && /^[a-zA-Z_]\w*$/.test(val)) {
+                    if (!declared.has(val)) {
+                        errors.push(`变量 '${val}' 在赋值前未声明`);
+                    }
                 }
+            }
+            if (action.target) {
                 declared.set(action.target, "any");
             }
         }
         else if (action.kind === "return") {
-            if (typeof action.value === "string" && /^[a-zA-Z_]\w*$/.test(action.value)) {
-                if (!declared.has(action.value) && !/^["']/.test(action.value) && action.value.length < 15)
-                    continue;
-                if (!declared.has(action.value))
-                    errors.push(`返回未定义变量 '${action.value}'`);
+            if (typeof action.value === "string") {
+                const val = action.value;
+                if (!isLiteral(val) && /^[a-zA-Z_]\w*$/.test(val)) {
+                    if (!declared.has(val)) {
+                        errors.push(`返回语句引用了未声明的变量 '${val}'`);
+                    }
+                }
             }
         }
         else if (action.kind === "if") {
-            if (typeof action.condition === "string" && declared.has(action.condition))
-                continue;
-            if (typeof action.condition === "string" && /^(true|false)$/.test(action.condition))
-                continue;
-            if (typeof action.condition === "string" && action.condition.length < 10) {
-                // 可能是表达式，放行
+            if (typeof action.condition === "string") {
+                const cond = action.condition;
+                if (!isLiteral(cond) && /^[a-zA-Z_]\w*$/.test(cond)) {
+                    if (!declared.has(cond) && cond !== 'true' && cond !== 'false') {
+                        errors.push(`条件中引用了未声明的变量 '${cond}'`);
+                    }
+                }
+            }
+            for (const a of (action.thenActions || [])) {
+                processAction(a);
             }
-            else {
-                errors.push(`条件中引用了未定义的变量 '${action.condition}'`);
+            for (const a of (action.elseActions || [])) {
+                processAction(a);
             }
-            errors.push(...checkVariableFlow(action.thenActions || []));
-            errors.push(...checkVariableFlow(action.elseActions || []));
         }
         else if (action.kind === "for") {
-            errors.push(...checkVariableFlow(action.bodyActions || []));
+            if (action.variable)
+                declared.set(action.variable, "any");
+            for (const a of (action.bodyActions || [])) {
+                processAction(a);
+            }
         }
+    };
+    for (const action of actions) {
+        processAction(action);
     }
     return errors;
 }
-function validateAction(action) {
+/**
+ * 校验单个动作的合法性（函数存在、类型匹配、参数数量）。
+ * @protocol namespace=dev_pipeline pre_states=["IR_EXTRACTED"] post_states=["ACTION_VALIDATED"]
+ */
+function validateAction(action, actionIndex) {
     const functions = loadIR();
     const errors = [];
+    const violations = [];
+    const idx = actionIndex ?? 0;
     if (!action || !["call", "if", "for", "assign", "return"].includes(action.kind)) {
-        errors.push(`无效动作类型: '${action?.kind}'`);
-        return { valid: false, errors };
+        const msg = `无效动作类型: '${action?.kind}'`;
+        errors.push(msg);
+        violations.push({ svl: 1, violatedConstraint: "symbol_existence", actionIndex: idx, description: msg });
+        return { valid: false, errors, violations };
     }
     if (action.kind === "call") {
         const fn = functions.find((f) => f.name === action.function);
         if (!fn) {
             if (action.function && BUILTIN_WHITELIST.has(action.function))
-                return { valid: true, errors: [] };
-            errors.push(`函数 '${action.function}' 不存在`);
-            return { valid: false, errors };
+                return { valid: true, errors: [], violations: [] };
+            const msg = `函数 '${action.function}' 不存在`;
+            errors.push(msg);
+            violations.push({ svl: 1, violatedConstraint: "symbol_existence", actionIndex: idx, missingStates: [action.function], description: msg });
+            return { valid: false, errors, violations };
         }
         if (!action.args) {
-            errors.push(`函数 '${action.function}' 缺少参数列表`);
-            return { valid: false, errors };
+            const msg = `函数 '${action.function}' 缺少参数列表`;
+            errors.push(msg);
+            violations.push({ svl: 2, violatedConstraint: "type_mismatch", actionIndex: idx, description: msg });
+            return { valid: false, errors, violations };
         }
         if (action.args.length !== fn.params.length) {
-            errors.push(`参数数量不匹配: 期望 ${fn.params.length}, 实际 ${action.args.length}`);
+            const msg = `参数数量不匹配: 期望 ${fn.params.length}, 实际 ${action.args.length}`;
+            errors.push(msg);
+            violations.push({ svl: 2, violatedConstraint: "type_mismatch", actionIndex: idx, description: msg });
         }
         action.args.forEach((arg, i) => {
             if (!arg) {
-                errors.push(`函数 '${action.function}' 的第${i}个参数为空`);
+                const msg = `函数 '${action.function}' 的第${i}个参数为空`;
+                errors.push(msg);
+                violations.push({ svl: 2, violatedConstraint: "type_mismatch", actionIndex: idx, description: msg });
                 return;
             }
             const expected = normalizeType(fn.params[i]?.type);
             const actual = normalizeType(arg.type);
             if (actual !== "any" && expected !== "any" && actual !== expected) {
-                errors.push(`类型不匹配: 参数 '${fn.params[i].name}' 期望 ${expected}, 实际 ${actual}`);
+                const msg = `类型不匹配: 参数 '${fn.params[i].name}' 期望 ${expected}, 实际 ${actual}`;
+                errors.push(msg);
+                violations.push({ svl: 2, violatedConstraint: "type_mismatch", actionIndex: idx, description: msg });
             }
         });
     }
     else if (action.kind === "if") {
         if (action.thenActions) {
-            for (const a of action.thenActions)
-                errors.push(...validateAction(a).errors);
+            for (const a of action.thenActions) {
+                const r = validateAction(a, idx);
+                errors.push(...r.errors);
+                violations.push(...r.violations);
+            }
         }
         if (action.elseActions) {
-            for (const a of action.elseActions)
-                errors.push(...validateAction(a).errors);
+            for (const a of action.elseActions) {
+                const r = validateAction(a, idx);
+                errors.push(...r.errors);
+                violations.push(...r.violations);
+            }
         }
     }
     else if (action.kind === "for") {
         if (action.bodyActions) {
-            for (const a of action.bodyActions)
-                errors.push(...validateAction(a).errors);
+            for (const a of action.bodyActions) {
+                const r = validateAction(a, idx);
+                errors.push(...r.errors);
+                violations.push(...r.violations);
+            }
         }
     }
-    return { valid: errors.length === 0, errors };
+    return { valid: errors.length === 0, errors, violations };
 }
+/**
+ * 批量校验动作序列 + 变量流向分析。
+ * @protocol namespace=dev_pipeline pre_states=["ACTION_VALIDATED"] post_states=["SEQUENCE_VALIDATED"] invalidate=["ACTION_VALIDATED"]
+ */
 function validateActionSequence(actions) {
     const errors = [];
-    for (const action of actions) {
-        const result = validateAction(action);
-        if (!result.valid)
+    const violations = [];
+    for (let i = 0; i < actions.length; i++) {
+        const result = validateAction(actions[i], i);
+        if (!result.valid) {
             errors.push(...result.errors);
+            violations.push(...result.violations);
+        }
     }
     if (errors.length === 0) {
-        errors.push(...checkVariableFlow(actions));
+        const flowErrors = checkVariableFlow(actions);
+        if (flowErrors.length > 0) {
+            errors.push(...flowErrors);
+            for (const msg of flowErrors) {
+                violations.push({ svl: 3, violatedConstraint: "dataflow", actionIndex: 0, description: msg });
+            }
+        }
     }
-    return { valid: errors.length === 0, errors };
+    return { valid: errors.length === 0, errors, violations };
 }

package/dist/verify-fps.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780345747502_y4u91 timestamp=2026-06-01T20:29:08.854Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 388 functions, 17 protocol rules
+const ledger_registry_1 = require("./ledger-registry");
+function main() {
+    const result = (0, ledger_registry_1.verifyAllFingerprints)("");
+    return result;
+}
+main();

package/dist/verify-ledgers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+// @progmune-generated session=sess_1780343460763_6iyf4 timestamp=2026-06-01T19:51:02.054Z ruleHash=9dec68bc2995e92a
+// Generated with IR constraint: 386 functions, 17 protocol rules
+const ledger_registry_1 = require("./ledger-registry");
+function main() {
+    const summary = (0, ledger_registry_1.verifyAllFingerprints)("defaultStr");
+    return summary;
+}
+main();

package/docs/whitepaper-style.css

@@ -0,0 +1,77 @@
+/* Progmune Runtime v2.2 Whitepaper — Clean Academic Style */
+body {
+  font-family: 'Times New Roman', Times, 'Songti SC', 'SimSun', serif;
+  font-size: 12pt;
+  line-height: 1.8;
+  color: #000;
+  max-width: 780px;
+  margin: 0 auto;
+  padding: 2.5rem 2rem;
+}
+
+/* ── Headings ── */
+h1 { font-size: 1.8rem; text-align: center; margin: 0 0 0.3rem; font-weight: bold; }
+h2 { font-size: 1.3rem; margin: 2rem 0 0.8rem; border-bottom: 1px solid #000; padding-bottom: 0.2rem; }
+h3 { font-size: 1.1rem; margin: 1.5rem 0 0.5rem; }
+h4 { font-size: 1rem; margin: 1.2rem 0 0.4rem; }
+
+/* ── Code ── */
+code {
+  font-family: 'Courier New', Courier, monospace;
+  font-size: 0.9em;
+  background: #f5f5f5;
+  padding: 0.1em 0.3em;
+}
+pre {
+  font-family: 'Courier New', Courier, monospace;
+  font-size: 0.85em;
+  background: #f8f8f8;
+  border: 1px solid #ddd;
+  padding: 0.8rem 1rem;
+  overflow-x: auto;
+  line-height: 1.5;
+}
+pre code { background: none; padding: 0; border: none; }
+
+/* ── Tables ── */
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 1rem 0 1.5rem;
+  font-size: 0.95em;
+}
+thead { background: #333; color: #fff; }
+th, td {
+  padding: 0.4rem 0.6rem;
+  text-align: left;
+  border: 1px solid #999;
+}
+
+/* ── Blockquote ── */
+blockquote {
+  border-left: 3px solid #666;
+  margin: 0.8rem 0;
+  padding: 0.3rem 0.8rem;
+  background: #f9f9f9;
+  font-style: italic;
+}
+
+/* ── Horizontal rule ── */
+hr { border: none; border-top: 1px solid #999; margin: 1.5rem 0; }
+
+/* ── Lists ── */
+ul, ol { padding-left: 1.5rem; }
+li { margin: 0.2rem 0; }
+
+/* ── Strong ── */
+strong { color: #000; }
+
+/* ── Print ── */
+@media print {
+  body { font-size: 10.5pt; max-width: none; padding: 0.8rem; }
+  h1 { font-size: 1.5rem; }
+  h2 { font-size: 1.15rem; }
+  pre { font-size: 0.8em; white-space: pre-wrap; }
+  table { font-size: 0.85em; }
+  @page { margin: 2cm; }
+}