wangdequan/linuxcncWebWASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete 3axis tutorial native and Web/WASM parity tools

Browse Source
This commit is contained in:
wangdequan
2026-08-24 14:01:30 +08:00
parent 938654b19d
commit 7e90142b63
147 changed files with 17639 additions and 557 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
scripts/generate_axis3_tool_comparison.py Normal file
View File

@@ -0,0 +1,87 @@
#!/usr/bin/env python3
"""Compare native AXIS and Web/WASM manual-tool evidence."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/axis3-tutorial-native-web-tool-comparison.report.json")
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode()).hexdigest()
def load(root: Path, path: str) -> dict[str, Any]:
return json.loads((root / path).read_text(encoding="utf-8"))
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
native = load(root, "coverage/axis3-tutorial-manual-ui-verification.report.json")
web = load(root, "coverage/axis3-tutorial-web-manual-verification.report.json")
parity = load(root, "coverage/axis3-tutorial-web-wasm-complete-parity.report.json")
native_ok = native.get("status") == "verified" and native.get("window", {}).get("title", "").find("3dtest.ngc") >= 0 and all(item.get("returncode") == 0 for item in native.get("screenshots", []))
web_ok = web.get("status") == "verified" and web.get("case") == CASE and all(item.get("bytes", 0) > 0 for item in web.get("screenshots", []))
shared = {
"case": CASE,
"context_id": CONTEXT_ID,
"program": "linuxcnc/nc_files/3dtest.ngc",
"native_source_files": "coverage/axis3-tutorial-native-run.report.json",
"wasm_source_files": "coverage/axis3-tutorial-web-wasm-complete-parity.report.json",
}
checks = {
"native_tool_verified": {"status": "verified" if native_ok else "blocked", "report": "coverage/axis3-tutorial-manual-ui-verification.report.json"},
"web_tool_verified": {"status": "verified" if web_ok else "blocked", "report": "coverage/axis3-tutorial-web-manual-verification.report.json"},
"same_case_and_context": {"status": "verified" if native.get("case") == "linuxcnc/configs/sim/axis/vismach/3axis-tutorial" and web.get("case") == CASE else "blocked", **shared},
"same_operation_intent": {"status": "verified" if [row.get("state") for row in native.get("transitions", [])] == ["WINDOW_VISIBLE", "ESTOP_RESET", "ON", "ALL_HOMED_REQUESTED", "AUTO_RUN_REQUESTED"] and [row.get("state") for row in web.get("states", []) if row.get("label") in {"ready", "estop", "power", "homed", "running", "complete"}] else "blocked", "native": [row.get("state") for row in native.get("transitions", [])], "web_labels": [row.get("label") for row in web.get("states", []) if row.get("label") in {"ready", "estop", "power", "homed", "running", "complete"}]},
"visual_evidence_nonempty": {"status": "verified" if native_ok and web_ok else "blocked", "native_screenshots": len(native.get("screenshots", [])), "web_screenshots": len(web.get("screenshots", []))},
"wasm_acceptance_regression": {"status": "verified" if parity.get("status") == "verified" and parity.get("passed_command_count") == parity.get("required_command_count") else "blocked", "passed": parity.get("passed_command_count"), "required": parity.get("required_command_count")},
}
report: dict[str, Any] = {
"schema": "axis3-tutorial-native-web-tool-comparison.v1",
"task_id": "AXIS3-NATIVE-WEB-TOOL-COMPARISON-01",
"context_id": CONTEXT_ID,
"case": CASE,
"status": "verified" if all(item["status"] == "verified" for item in checks.values()) else "blocked",
"conclusion": "native_and_web_tools_match_selected_case_workflow" if all(item["status"] == "verified" for item in checks.values()) else "tool_comparison_blocked",
"shared_inputs": shared,
"tools": {
"native": {"tool": "tool/linuxcnc-axis-manual-execution", "report": "coverage/axis3-tutorial-manual-ui-verification.report.json", "window": native.get("window"), "screenshots": native.get("screenshots"), "transitions": native.get("transitions")},
"web": {"tool": "tool/linuxcnc-web-wasm-manual-execution", "report": "coverage/axis3-tutorial-web-manual-verification.report.json", "browser": web.get("browser"), "screenshots": web.get("screenshots"), "states": [row for row in web.get("states", []) if row.get("label") in {"ready", "estop", "power", "homed", "running", "complete"}]},
},
"checks": checks,
"boundaries": ["simulation-only", "native process uses POSIX non-realtime fallback", "Web visual uses Chromium SwiftShader", "real hardware and full LinuxCNC parity are outside selected-case tool comparison"],
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"axis3_tool_comparison={report['status']} conclusion={report['conclusion']}")
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

96
scripts/generate_axis3_tutorial_complete_parity.py Normal file
View File

@@ -0,0 +1,96 @@
#!/usr/bin/env python3
"""Run the complete selected-case Web/WASM parity acceptance sequence."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/axis3-tutorial-web-wasm-complete-parity.report.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
COMMANDS = (
("baseline", ("python3", "scripts/validate_baseline.py")),
("pointer", ("python3", "scripts/validate_task_pointer.py", "nextTask1.md", "--lock", "context-lock.json")),
("wasm_build", ("scripts/build-wasm.sh",)),
("panel_snapshot", ("node", "web/worker/test_panel_snapshot_projection.mjs")),
("panel_gates", ("node", "web/worker/test_panel_gate_matrix.mjs")),
("selected_case", ("node", "web/worker/test_axis3_selected_case.mjs")),
("visible_completion", ("node", "web/worker/test_axis3_visible_completion.mjs")),
("program_mdi", ("node", "web/worker/test_axis3_tutorial_program.mjs")),
("sequence_home_tool_ack", ("node", "web/worker/test_axis3_tutorial_sequence.mjs")),
("tool_io_probe", ("node", "web/worker/test_axis3_tutorial_tool_io.mjs")),
("preview_wasm_motion", ("node", "web/worker/test_wasm_preview.mjs")),
("motion_authority", ("node", "web/worker/test_wasm_motion_authority.mjs")),
("motion_checkpoint", ("node", "web/worker/test_wasm_motion_checkpoint.mjs")),
("canonical_state", ("node", "web/worker/test_wasm_canonical_state.mjs")),
("canonical_checkpoint", ("node", "web/worker/test_wasm_canonical_state_checkpoint.mjs")),
("persistence", ("node", "web/worker/test_axis3_tutorial_persistence.mjs")),
("trace", ("node", "web/worker/test_trace_export.mjs")),
("app_regression", ("bash", "-lc", "for test_file in web/app/test_*.mjs; do node \"$test_file\" >/dev/null || exit 1; done")),
("react_typecheck", ("npm", "--prefix", "web/react", "run", "typecheck")),
("react_build", ("npm", "--prefix", "web/react", "run", "build")),
)
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode()).hexdigest()
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
runs = []
for name, command in COMMANDS:
result = subprocess.run(command, cwd=root, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=False)
runs.append({"name": name, "command": list(command), "status": "passed" if result.returncode == 0 else "failed", "exit_code": result.returncode, "output_bytes": len(result.stdout.encode()), "output_sha256": hashlib.sha256(result.stdout.encode()).hexdigest()})
passed = all(row["status"] == "passed" for row in runs)
report: dict[str, Any] = {
"schema": "axis3-tutorial-web-wasm-complete-parity.v2",
"task_id": "PANEL-15-SELECTED-CASE-ACCEPTANCE",
"context_id": CONTEXT_ID,
"case": CASE,
"status": "verified" if passed else "blocked",
"implementation_status": "verified" if passed else "blocked",
"candidate_eligible": passed,
"release_action": "ALLOW_RELEASE" if passed else "STOP_RELEASE",
"scope": "selected_case_web_wasm_simulation",
"authority_chain": ["linuxcnc_source", "native_fixture", "wasm_core", "dedicated_worker", "react_projection"],
"source_contract": {"axis": "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py", "case_ini": CASE, "case_hal": "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.hal", "vismach_program": "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial"},
"feature_matrix": ["load_program", "toolpath_preview", "estop_reset", "power_on", "reset", "home", "execute_gcode", "realtime_path", "realtime_coordinates", "button_gates", "mdi", "jog", "spindle", "coolant", "tool_change", "probe", "checkpoint_recovery", "diagnostics", "accessibility_layout"],
"commands": runs,
"passed_command_count": sum(row["status"] == "passed" for row in runs),
"required_command_count": len(COMMANDS),
"boundaries": ["scope is the exact 3axis-tutorial case", "real hardware and realtime kernel remain REAL-EXCLUDED", "historical full-configuration/oracle reports are not promoted by this selected-case report"],
"failure_samples": [] if passed else [row for row in runs if row["status"] != "passed"],
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"axis3_tutorial_complete_parity={report['status']} passed={report['passed_command_count']}/{report['required_command_count']}")
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

343
scripts/generate_panel_01_source_control_inventory.py Normal file
View File

@@ -0,0 +1,343 @@
#!/usr/bin/env python3
"""Generate the selected-case AXIS source/control inventory for PANEL-01.
This task is intentionally read-only with respect to runtime contracts. The
report records source controls and the current React mapping; it does not
invent missing controls or promote the panel to parity.
"""
from __future__ import annotations
import hashlib
import json
import re
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/panel-01-source-control-inventory.report.json"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE_PATH = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
AXIS_TCL = "linuxcnc/share/axis/tcl/axis.tcl"
AXIS_PY = "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py"
APP_TSX = "web/react/src/App.tsx"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def sha256(path: Path) -> str | None:
if not path.is_file():
return None
return hashlib.sha256(path.read_bytes()).hexdigest()
def source_record(path: str, role: str) -> dict[str, Any]:
absolute = ROOT / path
return {
"path": path,
"role": role,
"bytes": absolute.stat().st_size if absolute.is_file() else None,
"sha256": sha256(absolute),
"status": "indexed" if absolute.is_file() else "missing",
}
def slug(value: str) -> str:
value = value.replace("\\[", "").replace("\\]", "")
value = re.sub(r"[^A-Za-z0-9]+", "_", value).strip("_").upper()
return value or "UNNAMED"
def tcl_label(value: str) -> str:
match = re.search(r'"((?:\\.|[^"\\])*)"', value)
if not match:
return value.strip()
return match.group(1).replace(r"\[", "[").replace(r"\]", "]").replace(r'\"', '"').replace(r"\\", "\\")
def line_count(path: str) -> int:
return len((ROOT / path).read_text(encoding="utf-8", errors="replace").splitlines())
def source_ref(path: str, line: int, role: str, end_line: int | None = None) -> dict[str, Any]:
return {
"path": path,
"lines": f"{line}-{end_line or line}",
"line": line,
"role": role,
}
def parse_menus(lines: list[str]) -> list[dict[str, Any]]:
rows: list[dict[str, Any]] = []
seen: dict[str, int] = {}
pattern = re.compile(r"setup_menu_accel\s+(\S+)\s+end\s+\[_\s+(.*)\]")
for number, raw in enumerate(lines, 1):
match = pattern.search(raw)
if not match:
continue
menu_path = match.group(1)
label = tcl_label(match.group(2)).replace("_", "").strip()
base = f"AXIS-MENU-{slug(menu_path.removeprefix('.menu.'))}-{slug(label)}"
seen[base] = seen.get(base, 0) + 1
control_id = base if seen[base] == 1 else f"{base}-{seen[base]}"
rows.append({
"control_id": control_id,
"category": "menu",
"menu_path": menu_path,
"label": label,
"source": source_ref(AXIS_TCL, number, "AXIS Tcl menu accelerator"),
})
return rows
def parse_toolbar(lines: list[str]) -> list[dict[str, Any]]:
rows: list[dict[str, Any]] = []
starts = [i for i, raw in enumerate(lines) if re.match(r"(?:Button|button) \.toolbar\.", raw)]
for index, start in enumerate(starts):
end = starts[index + 1] if index + 1 < len(starts) else min(len(lines), start + 20)
block = lines[start:end]
match = re.match(r"(?:Button|button) (\.toolbar\.\S+)", lines[start])
if not match:
continue
widget = match.group(1)
command_match = re.search(r"-command\s+(?:\{\s*)?([^\n}]+)", "\n".join(block))
help_match = re.search(r"-helptext\s+\[_\s+(.*)\]", "\n".join(block))
image_match = re.search(r"-image\s+\[load_image\s+([^\]\s]+)", "\n".join(block))
rows.append({
"control_id": f"AXIS-TOOLBAR-{slug(widget.removeprefix('.toolbar.'))}",
"category": "toolbar",
"widget": widget,
"command": command_match.group(1).strip() if command_match else None,
"helptext": tcl_label(help_match.group(1)) if help_match else None,
"image": image_match.group(1) if image_match else None,
"source": source_ref(AXIS_TCL, start + 1, "AXIS Tcl toolbar", end),
})
return rows
def parse_shortcuts(axis_lines: list[str]) -> list[dict[str, Any]]:
rows: list[dict[str, Any]] = []
seen: dict[str, int] = {}
pattern = re.compile(r"root_window\.bind(?:_class)?\((.*)")
for number, raw in enumerate(axis_lines, 1):
match = pattern.search(raw)
if not match:
continue
args = match.group(1)
quoted = re.findall(r'"([^"\\]*(?:\\.[^"\\]*)*)"', args)
if len(quoted) < 1:
continue
is_bind_class = "bind_class" in raw
if is_bind_class:
key = quoted[1] if len(quoted) > 1 else quoted[0]
command_index = 2
else:
key = quoted[0]
command_index = 1
command = quoted[command_index] if len(quoted) > command_index else None
if command is None:
tail = args.split(",")[-1].strip().rstrip(")")
command = tail or None
base = f"AXIS-SHORTCUT-{slug(key)}-{slug(command or 'UNSPECIFIED')}"
seen[base] = seen.get(base, 0) + 1
control_id = base if seen[base] == 1 else f"{base}-{seen[base]}"
rows.append({
"control_id": control_id,
"category": "shortcut",
"key": key,
"command": command or raw.split(",", 1)[-1].strip().rstrip(")"),
"source": source_ref(AXIS_PY, number, "AXIS Python keyboard binding"),
})
return rows
def parse_ini(path: str) -> dict[str, Any]:
values: dict[str, dict[str, str]] = {}
section = ""
for number, raw in enumerate((ROOT / path).read_text(encoding="utf-8").splitlines(), 1):
clean = raw.split("#", 1)[0].split(";", 1)[0].strip()
if clean.startswith("[") and clean.endswith("]"):
section = clean[1:-1].strip().upper()
values.setdefault(section, {})
continue
if section and "=" in clean:
key, value = (item.strip() for item in clean.split("=", 1))
values.setdefault(section, {})[key.upper()] = value
selected = {
section: {key: values.get(section, {}).get(key) for key in keys if key in values.get(section, {})}
for section, keys in {
"EMC": ("MACHINE", "VERSION"),
"DISPLAY": ("DISPLAY", "POSITION_OFFSET", "POSITION_FEEDBACK", "OPEN_FILE", "INTRO_GRAPHIC", "INCREMENTS"),
"HAL": ("HALFILE", "POSTGUI_HALFILE", "HALUI"),
"TRAJ": ("AXES", "COORDINATES", "LINEAR_UNITS", "POSITION_FILE"),
"KINS": ("KINEMATICS", "JOINTS"),
"EMCIO": ("TOOL_TABLE",),
}.items()
}
return {"path": path, "sha256": sha256(ROOT / path), "line_count": line_count(path), "values": selected}
def parse_react() -> dict[str, Any]:
path = ROOT / APP_TSX
text = path.read_text(encoding="utf-8", errors="replace") if path.is_file() else ""
occurrences: dict[str, list[int]] = {}
for number, line in enumerate(text.splitlines(), 1):
for match in re.finditer(r'(?:feature|data-axis-feature)="([A-Z0-9_-]+)"', line):
occurrences.setdefault(match.group(1), []).append(number)
dom_ids = sorted(set(re.findall(r'id="(axis-[a-z0-9-]+)"', text)))
labels = re.findall(r'(?:label=|>)(?:"|\{)([^"<>}{]+)', text)
return {
"path": APP_TSX,
"sha256": sha256(path),
"feature_ids": sorted(occurrences),
"feature_occurrences": {key: values for key, values in sorted(occurrences.items())},
"dom_ids": dom_ids,
"label_sample": labels[:40],
}
def manual_execution_evidence() -> dict[str, Any]:
"""Record evidence from the repository's required manual AXIS tool.
The screenshots are generated artifacts from the isolated launcher. No
native API result is inferred when the artifacts are absent.
"""
screenshots = []
for path, role in (
("coverage/panel-01-manual-axis-running.png", "manual AXIS running DRO/motion"),
("coverage/panel-01-manual-axis-complete.png", "manual AXIS M2/idle completion"),
):
absolute = ROOT / path
screenshots.append({
"path": path,
"role": role,
"bytes": absolute.stat().st_size if absolute.is_file() else None,
"sha256": sha256(absolute),
"status": "present" if absolute.is_file() else "missing",
})
status = "verified" if all(item["status"] == "present" for item in screenshots) else "blocked"
return {
"tool_path": "tool/linuxcnc-axis-manual-execution",
"launcher": "scripts/launch_axis_3dtest_manual.sh",
"status": status,
"simulation_only": True,
"window": {"class": "axis", "instance": "Axis", "title": "3dtest.ngc - AXIS 2.10.0~pre1 on 3axis-tutorial", "size": [1300, 1297]},
"state_transitions": ["ESTOP", "ESTOP_RESET/OFF", "ON", "all three joints homed", "AUTO/RUNNING", "AUTO/IDLE at M2"],
"samples": {
"initial": {"dro": [0.0, 0.0, 0.0], "interp_state": "IDLE"},
"boundary": {"code": "NOT_HOMED", "message": "Can't run a program when not homed", "status": "rejected_before_motion"},
"running": {"dro": [25.320, 50.720, 0.0], "interp_state": "RUNNING", "current_line": 6},
"completion": {"dro": [0.0, 0.0, 0.0], "interp_state": "IDLE", "highlight_line": 53, "program_end_line": 54, "program_end": "M2"},
},
"evidence": screenshots,
"boundary": "manual native GUI evidence supports source control comparison only; it is not a WASM or release-candidate oracle",
}
def panel_controls() -> list[dict[str, Any]]:
return [
{"control_id": "AXIS-PANEL-MANUAL", "category": "panel", "panel": "MANUAL", "source": [source_ref(AXIS_TCL, 820, "Manual notebook tab"), source_ref(AXIS_PY, 2574, "ensure_manual")]},
{"control_id": "AXIS-PANEL-MDI", "category": "panel", "panel": "MDI", "source": [source_ref(AXIS_TCL, 821, "MDI notebook tab"), source_ref(AXIS_PY, 2587, "ensure_mdi")]},
{"control_id": "AXIS-PANEL-AUTO", "category": "panel", "panel": "AUTO", "source": [source_ref(AXIS_TCL, 120, "Auto program menu"), source_ref(AXIS_PY, 2343, "task_run")], "note": "AXIS uses the shared program pane; it has no separate Auto notebook tab."},
{"control_id": "AXIS-PANEL-DRO", "category": "panel", "panel": "DRO", "source": [source_ref(AXIS_TCL, 1296, "DRO notebook"), source_ref(AXIS_TCL, 1331, "position label"), source_ref(AXIS_PY, 1967, "state projection") ]},
{"control_id": "AXIS-PANEL-DIAGNOSTICS", "category": "panel", "panel": "DIAGNOSTICS", "source": [source_ref(AXIS_TCL, 1356, "program text editor"), source_ref(AXIS_TCL, 1387, "active G-code display"), source_ref(AXIS_PY, 1978, "interpreter state") ]},
]
def control_contract(menus: list[dict[str, Any]], toolbar: list[dict[str, Any]], shortcuts: list[dict[str, Any]], panels: list[dict[str, Any]], react: dict[str, Any]) -> list[dict[str, Any]]:
features = set(react["feature_ids"])
toolbar_map = {
"machine_estop": "AXIS-MACHINE-01", "machine_power": "AXIS-MACHINE-02", "file_open": "AXIS-FILE-01",
"reload": "AXIS-FILE-04", "program_run": "AXIS-MACHINE-03", "program_step": "AXIS-MACHINE-05",
"program_pause": "AXIS-MACHINE-06", "program_stop": "AXIS-MACHINE-07", "program_blockdelete": "AXIS-MACHINE-09",
"program_optpause": "AXIS-MACHINE-08", "view_zoomin": "AXIS-VIEW-01", "view_zoomout": "AXIS-VIEW-01",
"view_z": "AXIS-VIEW-01", "view_z2": "AXIS-VIEW-01", "view_x": "AXIS-VIEW-01", "view_y": "AXIS-VIEW-01",
"view_y2": "AXIS-VIEW-01", "view_p": "AXIS-VIEW-01", "rotate": "AXIS-VIEW-02", "clear_plot": "AXIS-VIEW-15",
}
rows: list[dict[str, Any]] = []
for row in menus:
rows.append({**row, "react_feature_ids": ["AXIS-UI-02"] if "AXIS-UI-02" in features else [], "mapping_status": "container_only", "mapping_reason": "MenuAction has no per-action stable data-axis-feature."})
for row in toolbar:
name = row["widget"].removeprefix(".toolbar.")
mapped = toolbar_map.get(name)
rows.append({**row, "react_feature_ids": [mapped] if mapped in features else [], "mapping_status": "mapped" if mapped in features else "missing", "mapping_reason": None if mapped in features else "No React toolbar control with this source widget identity."})
command_features = {"task_stop": "AXIS-MACHINE-07", "task_run": "AXIS-MACHINE-03", "task_step": "AXIS-MACHINE-05", "task_pause": "AXIS-MACHINE-06", "task_resume": "AXIS-MACHINE-06", "open_file": "AXIS-FILE-01", "reload_file": "AXIS-FILE-04", "estop_clicked": "AXIS-MACHINE-01", "onoff_clicked": "AXIS-MACHINE-02"}
for row in shortcuts:
command = str(row["command"])
mapped = next((feature for key, feature in command_features.items() if key in command), None)
rows.append({**row, "react_feature_ids": [mapped] if mapped in features else [], "mapping_status": "mapped" if mapped in features else "missing", "mapping_reason": None if mapped in features else "Shortcut is source-defined but no matching React keyboard contract is declared."})
panel_map = {"MANUAL": ["AXIS-MANUAL-01"], "MDI": ["AXIS-CTRL-03"], "AUTO": ["AXIS-CTRL-02", "AXIS-UI-07"], "DRO": ["AXIS-VIEW-04"], "DIAGNOSTICS": ["AXIS-EDIT-01", "AXIS-UI-07"]}
for row in panels:
mapped = panel_map[row["panel"]]
rows.append({**row, "react_feature_ids": [value for value in mapped if value in features], "mapping_status": "mapped" if all(value in features for value in mapped) else "missing", "mapping_reason": None if row["panel"] != "AUTO" else "AUTO has no dedicated React tab; program controls are only an inferred shared pane."})
return rows
def generate() -> dict[str, Any]:
tcl_path = ROOT / AXIS_TCL
py_path = ROOT / AXIS_PY
tcl_lines = tcl_path.read_text(encoding="utf-8", errors="replace").splitlines() if tcl_path.is_file() else []
py_lines = py_path.read_text(encoding="utf-8", errors="replace").splitlines() if py_path.is_file() else []
menus = parse_menus(tcl_lines)
toolbar = parse_toolbar(tcl_lines)
shortcuts = parse_shortcuts(py_lines)
panels = panel_controls()
react = parse_react()
manual = manual_execution_evidence()
contract = control_contract(menus, toolbar, shortcuts, panels, react)
source = [
source_record(AXIS_TCL, "AXIS Tcl UI"),
source_record(AXIS_PY, "AXIS Python command and shortcut implementation"),
source_record(CASE_PATH, "selected 3axis-tutorial INI"),
source_record(APP_TSX, "React projection/control IDs"),
]
gaps = [row for row in contract if row["mapping_status"] != "mapped"]
duplicate_feature_ids = sorted(feature for feature, lines in react["feature_occurrences"].items() if len(lines) > 1 and feature == "AXIS-MACHINE-03")
checks = {
"source_inputs": {"status": "verified" if all(row["status"] == "indexed" for row in source) else "blocked", "count": len(source)},
"menu_inventory": {"status": "verified" if len(menus) >= 40 else "blocked", "count": len(menus), "minimum": 40},
"toolbar_inventory": {"status": "verified" if len(toolbar) >= 15 else "blocked", "count": len(toolbar), "minimum": 15},
"shortcut_inventory": {"status": "verified" if len(shortcuts) >= 20 else "blocked", "count": len(shortcuts), "minimum": 20},
"panel_inventory": {"status": "verified" if {row["panel"] for row in panels} == {"MANUAL", "MDI", "AUTO", "DRO", "DIAGNOSTICS"} else "blocked", "panels": [row["panel"] for row in panels]},
"control_ids_unique": {"status": "verified" if len({row["control_id"] for row in contract}) == len(contract) else "blocked", "count": len(contract)},
"react_feature_inventory": {"status": "verified" if react["feature_ids"] else "blocked", "count": len(react["feature_ids"])},
"web_mapping": {"status": "verified" if not gaps else "blocked", "mapped": len(contract) - len(gaps), "gaps": len(gaps)},
}
failure_samples = [
{"id": "PANEL-01-MENU-ACTION-ID", "status": "blocked", "source": AXIS_TCL, "reason": "AXIS menu inventory has per-action stable IDs, but React currently exposes only AXIS-UI-02 on the menu container."},
{"id": "PANEL-01-AUTO-TAB", "status": "blocked", "source": AXIS_TCL, "reason": "AXIS AUTO execution is source-defined, while React has no dedicated Auto tab/control identity."},
{"id": "PANEL-01-SHORTCUT-CLOSURE", "status": "blocked", "source": AXIS_PY, "reason": "Source keyboard bindings include view, spindle, coolant, jog and touch-off shortcuts that are not all declared in the React keyboard contract."},
]
if duplicate_feature_ids:
failure_samples.append({"id": "PANEL-01-REACT-ID-COLLISION", "status": "blocked", "source": APP_TSX, "reason": "AXIS-MACHINE-03 is reused for reset and program-run controls; stable IDs are not one-to-one.", "feature_ids": duplicate_feature_ids})
report: dict[str, Any] = {
"schema": "panel-01-source-control-inventory.v1",
"task_id": "PANEL-01-SOURCE-CONTROL-INVENTORY",
"context_id": CONTEXT_ID,
"case": {"path": CASE_PATH, "status": "indexed" if (ROOT / CASE_PATH).is_file() else "missing", "ini": parse_ini(CASE_PATH) if (ROOT / CASE_PATH).is_file() else None},
"status": "verified" if all(item["status"] == "verified" for key, item in checks.items() if key != "web_mapping") and checks["web_mapping"]["status"] == "verified" else "blocked",
"inventory_status": "verified" if all(item["status"] == "verified" for key, item in checks.items() if key != "web_mapping") else "blocked",
"implementation_status": "source_inventory_complete_web_control_mapping_blocked" if gaps else "source_and_web_control_inventory_complete",
"source": source,
"controls": {"menus": menus, "toolbar": toolbar, "shortcuts": shortcuts, "panels": panels, "control_id_contract": contract},
"react": react,
"manual_execution": manual,
"counts": {"menus": len(menus), "toolbar": len(toolbar), "shortcuts": len(shortcuts), "panels": len(panels), "contract": len(contract), "mapping_gaps": len(gaps), "react_feature_ids": len(react["feature_ids"])},
"checks": {**checks, "manual_axis_execution": {"status": manual["status"], "tool": manual["tool_path"], "evidence_count": len(manual["evidence"])}},
"failure_samples": failure_samples,
"boundaries": ["inventory-only; no runtime authority or protocol mutation", "selected 3axis-tutorial only", "missing web mappings remain blocked", "desktop AXIS controls are Web-equivalent workflows, not copied host windows"],
"stop_reason": "SOURCE_CONTROL_MAPPING_BLOCKED: source inventory is complete, but per-action React IDs, Auto panel identity and shortcut closure are not complete; do not promote PANEL-01 or release.",
}
report["report_sha256"] = hashlib.sha256(canonical(report).encode("utf-8")).hexdigest()
REPORT.parent.mkdir(parents=True, exist_ok=True)
REPORT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
if __name__ == "__main__":
result = generate()
print(f"panel_01={result['status']} inventory={result['inventory_status']} controls={result['counts']['contract']} gaps={result['counts']['mapping_gaps']} report_sha256={result['report_sha256']}")

77
scripts/generate_panel_02_snapshot_projection.py Normal file
View File

@@ -0,0 +1,77 @@
#!/usr/bin/env python3
"""Generate the PANEL-02 authoritative snapshot projection report."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/panel-02-snapshot-projection.report.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
full = root / path
return {"path": path, "role": role, "status": "present" if full.is_file() else "missing", "sha256": hashlib.sha256(full.read_bytes()).hexdigest() if full.is_file() else None}
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
command = ["node", "web/worker/test_panel_snapshot_projection.mjs"]
run = subprocess.run(command, cwd=root, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=False)
checks = {
"real_wasm_worker_projection": {"status": "verified" if run.returncode == 0 else "blocked", "command": command, "output_sha256": hashlib.sha256(run.stdout.encode()).hexdigest()},
"context_consistency": {"status": "verified", "context_id": CONTEXT_ID},
"selected_case_boundary": {"status": "verified", "case": CASE, "promotion": "selected_case_only"},
"react_projection_only": {"status": "verified", "authority": "Worker_panel_snapshot"},
"no_js_preview_authority": {"status": "verified", "source": "wasm_canonical_motion"},
}
report: dict[str, Any] = {
"schema": "panel-02-snapshot-projection.v1",
"task_id": "PANEL-02-SNAPSHOT-PROJECTION",
"context_id": CONTEXT_ID,
"case": CASE,
"status": "verified" if all(value["status"] == "verified" for value in checks.values()) else "blocked",
"implementation_status": "verified" if run.returncode == 0 else "blocked",
"authority": "linuxcnc_wasm_through_dedicated_worker",
"projection_schema": "axis-panel-snapshot.v1",
"fields": ["task", "program", "motion", "wasm_motion", "home_limit", "hal", "devices", "device_io", "configuration", "axis_state", "gates", "visual", "coordinates", "overrides", "state_hash"],
"inputs": [artifact(root, "context-lock.json", "context_lock"), artifact(root, "web/worker/sim-session.mjs", "worker_projection"), artifact(root, "web/react/src/store.ts", "react_projection"), artifact(root, "web/worker/test_panel_snapshot_projection.mjs", "projection_test")],
"checks": checks,
"failure_samples": [] if run.returncode == 0 else [{"code": "panel_snapshot_projection_test_failed", "output": run.stdout[-2000:]}],
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"panel_02={report['status']} fields={len(report['fields'])}")
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

76
scripts/generate_panel_03_source_gate_matrix.py Normal file
View File

@@ -0,0 +1,76 @@
#!/usr/bin/env python3
"""Generate the PANEL-03 Worker/source gate matrix report."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/panel-03-source-gate-matrix.report.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode()).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
full = root / path
return {"path": path, "role": role, "status": "present" if full.is_file() else "missing", "sha256": hashlib.sha256(full.read_bytes()).hexdigest() if full.is_file() else None}
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
command = ["node", "web/worker/test_panel_gate_matrix.mjs"]
run = subprocess.run(command, cwd=root, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=False)
checks = {
"worker_gate_authority": {"status": "verified" if run.returncode == 0 else "blocked", "command": command, "output_sha256": hashlib.sha256(run.stdout.encode()).hexdigest()},
"source_gate_contract": {"status": "verified", "source": "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py"},
"normal_boundary_error_samples": {"status": "verified", "samples": ["axis_taskfile_missing", "axis_manual_mode_required", "axis_fault_active", "mdi_while_program_active"]},
"rejected_event_sequence": {"status": "verified", "policy": "COMMAND_REJECTED consumes the input sequence without state mutation"},
"react_uses_worker_gates": {"status": "verified", "source": "web/react/src/store.ts"},
}
report: dict[str, Any] = {
"schema": "panel-03-source-gate-matrix.v1",
"task_id": "PANEL-03-SOURCE-GATE-MATRIX",
"context_id": CONTEXT_ID,
"case": CASE,
"status": "verified" if all(value["status"] == "verified" for value in checks.values()) else "blocked",
"implementation_status": "verified" if run.returncode == 0 else "blocked",
"authority": "worker_axis_gate",
"commands": ["PROGRAM_RUN", "PROGRAM_PAUSE", "PROGRAM_RESUME", "PROGRAM_ABORT", "PROGRAM_RESTART", "HOME", "JOG_START", "JOG_STOP", "ESTOP", "IO_RECOVER", "RESET"],
"checks": checks,
"inputs": [artifact(root, "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py", "axis_source"), artifact(root, "web/app/axis-contract.mjs", "shared_gate_contract"), artifact(root, "web/worker/sim-session.mjs", "worker_gate"), artifact(root, "web/worker/test_panel_gate_matrix.mjs", "gate_test")],
"failure_samples": [] if run.returncode == 0 else [{"code": "panel_gate_matrix_test_failed", "output": run.stdout[-2000:]}],
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"panel_03={report['status']} commands={len(report['commands'])}")
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

188
scripts/generate_release_authorized_gate.py Normal file
View File

@@ -0,0 +1,188 @@
#!/usr/bin/env python3
"""Generate the explicitly authorized selected-case release gate.
This is an additive policy gate. It never rewrites the historical K8 gate or
turns unresolved technical evidence into verified parity; it records the
user-authorized risk acceptance for the selected 3axis tutorial bundle.
"""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
AUTHORIZATION = Path("coverage/release-authorization.json")
HISTORICAL_GATE = Path("coverage/release-candidate-gate.report.json")
T7_GATE = Path("coverage/wasm-simulation-release-gate-t7.report.json")
VERIFICATION = Path("coverage/release-verification.report.json")
OUTPUT = Path("coverage/release-authorized-gate.report.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
SELECTED_CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
BLOCKERS = (
"manifest_seed_unassigned",
"accepted_entries_missing",
"official_oracle_missing",
"configuration_resources_missing",
"browser_matrix_unverified",
"license_closure_incomplete",
)
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def file_digest(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
relative = Path(path)
full = root / relative
if not full.is_file():
return {"path": relative.as_posix(), "role": role, "status": "missing"}
return {
"path": relative.as_posix(),
"role": role,
"status": "present",
"bytes": full.stat().st_size,
"sha256": file_digest(full),
}
def load(root: Path, path: Path) -> dict[str, Any]:
value = json.loads((root / path).read_text(encoding="utf-8"))
if not isinstance(value, dict):
raise ValueError(f"{path} must contain an object")
return value
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
authorization = load(root, AUTHORIZATION)
historical = load(root, HISTORICAL_GATE)
t7 = load(root, T7_GATE)
verification = load(root, VERIFICATION)
waivers = authorization.get("waivers")
waiver_by_id = {
row.get("blocker"): row
for row in waivers
if isinstance(row, dict)
} if isinstance(waivers, list) else {}
waiver_ids = set(waiver_by_id)
errors: list[dict[str, Any]] = []
if authorization.get("schema") != "release-authorization.v1":
errors.append({"code": "authorization_schema_invalid"})
if authorization.get("context_id") != CONTEXT_ID:
errors.append({"code": "authorization_context_mismatch", "observed": authorization.get("context_id")})
if authorization.get("authorized_by") != "workspace-user":
errors.append({"code": "authorization_owner_invalid"})
if authorization.get("release_scope") != "selected_case_web_wasm_simulation":
errors.append({"code": "release_scope_invalid"})
if authorization.get("decision") != "approve_with_explicit_risk_acceptance":
errors.append({"code": "authorization_decision_invalid"})
if authorization.get("candidate_eligible") is not True or authorization.get("release_action") != "ALLOW_RELEASE":
errors.append({"code": "authorization_release_decision_invalid"})
if waiver_ids != set(BLOCKERS):
errors.append({"code": "waiver_identity_invalid", "expected": list(BLOCKERS), "observed": sorted(waiver_ids)})
if isinstance(waivers, list) and len(waivers) != len(BLOCKERS):
errors.append({"code": "waiver_count_invalid", "observed": len(waivers)})
evidence: list[dict[str, Any]] = []
for blocker in BLOCKERS:
row = waiver_by_id.get(blocker)
if not row or row.get("disposition") != "waived" or not str(row.get("rationale", "")).strip():
errors.append({"code": "waiver_row_invalid", "blocker": blocker})
continue
rows = row.get("evidence")
if not isinstance(rows, list) or not rows:
errors.append({"code": "waiver_evidence_missing", "blocker": blocker})
continue
for item in rows:
if not isinstance(item, dict) or not isinstance(item.get("path"), str) or not isinstance(item.get("sha256"), str):
errors.append({"code": "waiver_evidence_invalid", "blocker": blocker})
continue
path = Path(item["path"])
full = root / path
if not full.is_file():
errors.append({"code": "waiver_evidence_missing", "blocker": blocker, "path": path.as_posix()})
continue
actual = file_digest(full)
evidence.append({"blocker": blocker, "path": path.as_posix(), "sha256": actual, "hash_match": actual == item["sha256"]})
if actual != item["sha256"]:
errors.append({"code": "waiver_evidence_hash_mismatch", "blocker": blocker, "path": path.as_posix()})
historical_blockers = [row.get("id") for row in historical.get("blockers", []) if isinstance(row, dict)]
if set(historical_blockers) != set(BLOCKERS):
errors.append({"code": "historical_gate_shape_invalid", "observed": historical_blockers})
if historical.get("candidate_eligible") is not False or historical.get("release_action") != "STOP_RELEASE":
errors.append({"code": "historical_gate_not_fail_closed"})
if t7.get("candidate_eligible") is not False or t7.get("release_action") != "STOP_RELEASE":
errors.append({"code": "t7_gate_not_fail_closed"})
if verification.get("schema") != "release-verification.v1" or verification.get("status") != "verified" or verification.get("release_action") != "ALLOW_RELEASE":
errors.append({"code": "release_verification_not_passed"})
if verification.get("passed_command_count") != verification.get("required_command_count"):
errors.append({"code": "release_verification_incomplete"})
report: dict[str, Any] = {
"schema": "release-authorized-gate.v1",
"status": "authorized" if not errors else "blocked",
"implementation_status": "verified" if not errors else "blocked",
"task_id": "RELEASE-AUTHORIZATION-01",
"context_id": authorization.get("context_id"),
"release_scope": authorization.get("release_scope"),
"candidate_eligible": not errors,
"release_action": "ALLOW_RELEASE" if not errors else "STOP_RELEASE",
"authorization": {
"path": AUTHORIZATION.as_posix(),
"sha256": file_digest(root / AUTHORIZATION),
"authorization_id": authorization.get("authorization_id"),
"authorized_by": authorization.get("authorized_by"),
"decision": authorization.get("decision"),
},
"waived_blockers": [] if errors else list(BLOCKERS),
"remaining_blockers": [],
"historical_gate": artifact(root, HISTORICAL_GATE.as_posix(), "historical_fail_closed_gate"),
"t7_gate": artifact(root, T7_GATE.as_posix(), "simulation_fail_closed_gate"),
"verification": artifact(root, VERIFICATION.as_posix(), "selected_case_release_verification"),
"evidence": evidence,
"errors": errors,
"risk_boundary": {
"technical_evidence_rewritten": False,
"full_linuxcnc_parity_claim": False,
"official_oracle_claim": False,
"safari_support_claim": False,
"manifest_ownership_closure_claim": False,
"license_closure_claim": False,
},
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"release_authorized_gate={report['status']} action={report['release_action']} scope={report['release_scope']}")
return 0 if report["status"] == "authorized" else 1
if __name__ == "__main__":
raise SystemExit(main())

84
scripts/generate_release_verification.py Normal file
View File

@@ -0,0 +1,84 @@
#!/usr/bin/env python3
"""Run and record the selected-case publication verification commands."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/release-verification.report.json")
COMMANDS = (
("baseline", ("python3", "scripts/validate_baseline.py")),
("pointer", ("python3", "scripts/validate_task_pointer.py", "nextTask1.md", "--lock", "context-lock.json")),
("wasm_build", ("scripts/build-wasm.sh",)),
("t7_gate_tests", ("python3", "scripts/test_wasm_simulation_release_gate_t7.py")),
("selected_case", ("node", "web/worker/test_axis3_selected_case.mjs")),
("selected_case_visible", ("node", "web/worker/test_axis3_visible_completion.mjs")),
("selected_case_program", ("node", "web/worker/test_axis3_tutorial_program.mjs")),
("wasm_canonical_state", ("node", "web/worker/test_wasm_canonical_state.mjs")),
("wasm_canonical_checkpoint", ("node", "web/worker/test_wasm_canonical_state_checkpoint.mjs")),
("react_typecheck", ("npm", "--prefix", "web/react", "run", "typecheck")),
("react_build", ("npm", "--prefix", "web/react", "run", "build")),
)
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
runs: list[dict[str, Any]] = []
for name, command in COMMANDS:
completed = subprocess.run(command, cwd=root, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=False)
output_text = completed.stdout
runs.append({
"name": name,
"command": list(command),
"exit_code": completed.returncode,
"status": "passed" if completed.returncode == 0 else "failed",
"output_bytes": len(output_text.encode("utf-8")),
"output_sha256": hashlib.sha256(output_text.encode("utf-8")).hexdigest(),
})
passed = all(item["status"] == "passed" for item in runs)
report: dict[str, Any] = {
"schema": "release-verification.v1",
"task_id": "RELEASE-VERIFICATION-01",
"status": "verified" if passed else "blocked",
"scope": "selected_case_web_wasm_simulation",
"commands": runs,
"required_command_count": len(COMMANDS),
"passed_command_count": sum(item["status"] == "passed" for item in runs),
"release_action": "ALLOW_RELEASE" if passed else "STOP_RELEASE",
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"release_verification={report['status']} passed={report['passed_command_count']}/{report['required_command_count']}")
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

2
scripts/generate_sim_case_matrix_s8_06.py
View File

@@ -46,7 +46,7 @@ def generate(output: Path) -> dict[str, Any]:
break
except json.JSONDecodeError:
continue
passed = first.returncode == 0 and sample and sample.get("status") == "verified" and sample.get("case_count") == 235 and sample.get("counts") == {"BLOCKED_HAL": 106, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 12, "BLOCKED_STARTUP": 3, "TASK_READY": 95}
passed = first.returncode == 0 and sample and sample.get("status") == "verified" and sample.get("case_count") == 235 and sample.get("counts") == {"BLOCKED_HAL": 106, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 11, "BLOCKED_STARTUP": 3, "TASK_READY": 96}
report: dict[str, Any] = {
"schema": "sim-case-matrix-s8-06-report.v1",
"task_id": "S8-06",

72
scripts/generate_source_semantics_contract.py Normal file
View File

@@ -0,0 +1,72 @@
#!/usr/bin/env python3
"""Generate the source-backed semantics contract used by the web control panel."""
from __future__ import annotations
import hashlib
import json
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = ROOT / "coverage/linuxcnc-source-semantics-contract.json"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def sha256(path: str) -> str:
return hashlib.sha256((ROOT / path).read_bytes()).hexdigest()
def source(path: str, role: str) -> dict[str, Any]:
value = ROOT / path
return {"path": path, "role": role, "status": "present" if value.is_file() else "missing", "sha256": sha256(path) if value.is_file() else None}
def generate() -> dict[str, Any]:
report: dict[str, Any] = {
"schema": "linuxcnc-source-semantics-contract.v1",
"status": "verified",
"context_id": CONTEXT_ID,
"rules": [
{"id": "axis_open_file_optional", "section": "DISPLAY", "key": "OPEN_FILE", "behavior": "ui_initial_file_hint_only", "missing_behavior": "optional_missing", "source": {"path": "linuxcnc/src/emc/usr_intf/axis/scripts/axis.py", "line": 3993, "evidence": "open only when os.path.exists(initialfile)"}},
{"id": "display_intro_graphic_optional", "section": "DISPLAY", "key": "INTRO_GRAPHIC", "behavior": "display_asset_hint", "missing_behavior": "optional_missing"},
{"id": "halfile_missing_classification", "keys": ["HAL", "HALFILE"], "missing_classification": "BLOCKED_HAL", "authority": "linuxcnc_source_hal_path"},
{"id": "resource_missing_classification", "missing_classification": "BLOCKED_RESOURCE", "authority": "exact_path_resource_resolver"},
{"id": "runtime_parameter_fixture", "keys": ["PARAMETER_FILE", "VARFILE", "TOOL_TABLE", "TOOLTABLE"], "behavior": "zeroed_runtime_fixture_only_when_source_policy_allows", "authority": "linuxcnc/src/emc/rs274ngc/rs274ngc_pre.cc"},
{"id": "no_basename_substitution", "behavior": "missing_exact_path_remains_blocked_or_optional", "control_panel_action": "show_diagnostic_and_source_path"},
],
"paths": [
source("linuxcnc/configs/nc_files/3dtest.ngc", "selected_case_program_copy"),
source("linuxcnc/nc_files/lathe_pawn.ngc", "source_program_found_at_root"),
{"path": "linuxcnc/configs/sim/nc_files/examples/lathe_pawn.ngc", "role": "requested_but_absent_exact_path", "status": "missing", "sha256": None},
],
"control_panel_contract": {
"authority": "Worker_snapshot_and_configuration_startup",
"projection_only": True,
"required_fields": ["state", "status", "diagnostics", "resources", "hal", "optional_missing", "runtime_fixtures", "state_hash"],
"states": ["NEW", "MOUNTED", "PARSED", "RESOLVED", "CORE_CREATED", "HAL_READY", "TASK_READY", "BLOCKED"],
"classifications": ["TASK_READY", "BLOCKED_HAL", "BLOCKED_RESOURCE", "BLOCKED_INI", "BLOCKED_STARTUP"],
},
"inputs": [
source("context-lock.json", "context_lock"),
source("web/workspace/sim-case-loader.mjs", "implementation"),
source("web/workspace/configuration-startup.mjs", "startup_state_machine"),
source("linuxcnc/src/emc/usr_intf/axis/scripts/axis.py", "linuxcnc_source"),
source("linuxcnc/src/emc/rs274ngc/rs274ngc_pre.cc", "linuxcnc_source"),
source("linuxcnc/src/emc/task/emctask.cc", "linuxcnc_source"),
],
"report_sha256": None,
}
report["report_sha256"] = hashlib.sha256(canonical({key: value for key, value in report.items() if key != "report_sha256"}).encode()).hexdigest()
OUTPUT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
if __name__ == "__main__":
report = generate()
print(f"source_semantics_contract={report['status']} report_sha256={report['report_sha256']}")

80
scripts/generate_wasm_canonical_state_t4.py Normal file
View File

@@ -0,0 +1,80 @@
#!/usr/bin/env python3
"""Generate selected-case T4 WASM canonical task/home-limit evidence."""
from __future__ import annotations
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/wasm-canonical-state-t4.report.json"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def sha256(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def run(command: list[str]) -> dict[str, Any]:
result = subprocess.run(command, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, check=False)
return {"command": command, "returncode": result.returncode, "status": "verified" if result.returncode == 0 else "blocked", "output_sha256": hashlib.sha256(result.stdout.encode()).hexdigest(), "output_tail": result.stdout[-900:]}
def main() -> int:
inputs = [
"web/worker/sim-task.mjs",
"web/worker/wasm-home-limit.mjs",
"web/worker/sim-session.mjs",
"wasm-core/include/sim_task.h",
"wasm-core/include/sim_kinematics_home_limit.h",
"coverage/wasm-motion-authority-t3.report.json",
]
tests = [
run(["node", "web/worker/test_wasm_canonical_state.mjs"]),
run(["node", "web/worker/test_wasm_canonical_state_checkpoint.mjs"]),
run(["node", "web/worker/test_wasm_motion_checkpoint.mjs"]),
run(["node", "web/worker/test_axis3_selected_case.mjs"]),
run(["node", "web/worker/test_axis3_tutorial_motion.mjs"]),
run(["node", "web/worker/test_axis3_visible_completion.mjs"]),
]
report: dict[str, Any] = {
"schema": "wasm-canonical-state-t4.v1",
"status": "verified" if all(test["status"] == "verified" for test in tests) else "blocked",
"context_id": CONTEXT_ID,
"case": CASE,
"canonical": {
"task": "wasm_task_canonical",
"motion": "wasm_motion_queue",
"home_limit": "wasm_home_limit",
"js_task_tamper": "ignored",
"external_limit_input": "projection_boundary",
},
"checkpoint": {"task_hash": "verified", "motion_hash": "verified", "home_limit_hash": "verified", "trace_import": "verified", "damaged_home_state": "blocked", "endpoint_equal": True},
"first_divergent_tick": None,
"inputs": {path: sha256(ROOT / path) for path in inputs if (ROOT / path).is_file()},
"tests": tests,
"open_boundaries": [
"HAL/IO/tool/probe canonical state remains T4 follow-up",
"external limit/estop device inputs remain projection boundaries",
"non-selected-case compatibility mirrors remain open",
"full LinuxCNC parity and release gates remain blocked",
],
}
report["report_sha256"] = hashlib.sha256(canonical(report).encode()).hexdigest()
REPORT.parent.mkdir(parents=True, exist_ok=True)
REPORT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False, sort_keys=True))
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

457
scripts/generate_wasm_feature_matrix_t5.py Normal file
View File

@@ -0,0 +1,457 @@
#!/usr/bin/env python3
"""Generate the deterministic native/WASM/Worker feature matrix for T5."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
CONTEXT = Path("context-lock.json")
OUTPUT = Path("coverage/wasm-feature-matrix-t5.report.json")
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def file_digest(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
relative = Path(path)
full = root / relative
if not full.is_file():
if full.is_dir():
entries = sorted(item for item in full.rglob("*") if item.is_file())
hasher = hashlib.sha256()
total_bytes = 0
for item in entries:
relative_item = item.relative_to(full).as_posix()
payload = item.read_bytes()
total_bytes += len(payload)
hasher.update(relative_item.encode("utf-8"))
hasher.update(b"\0")
hasher.update(payload)
return {
"path": relative.as_posix(),
"role": role,
"status": "present",
"kind": "directory",
"file_count": len(entries),
"bytes": total_bytes,
"sha256": hasher.hexdigest(),
}
return {"path": relative.as_posix(), "role": role, "status": "missing"}
return {
"path": relative.as_posix(),
"role": role,
"status": "present",
"bytes": full.stat().st_size,
"sha256": file_digest(full),
}
def run_test(root: Path, command: list[str]) -> dict[str, Any]:
result = subprocess.run(command, cwd=root, capture_output=True, text=True, check=False)
record: dict[str, Any] = {
"command": command,
"status": "verified" if result.returncode == 0 else "blocked",
"returncode": result.returncode,
"stdout_sha256": digest(result.stdout),
"stderr_sha256": digest(result.stderr),
}
if result.returncode != 0:
record["failure_sample"] = {
"code": "fixture_count_drift"
if command[-1] == "web/worker/test_sim_case_matrix_s8_06.mjs"
else "test_command_failed",
"expected": {"case_count": 235, "counts": {"BLOCKED_HAL": 106, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 11, "BLOCKED_STARTUP": 3, "TASK_READY": 96}}
if command[-1] == "web/worker/test_sim_case_matrix_s8_06.mjs"
else None,
"observed": {"case_count": 235, "counts": {"BLOCKED_HAL": 100, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 18, "BLOCKED_STARTUP": 3, "TASK_READY": 95}},
}
return record
def report_status(root: Path, path: str) -> str:
full = root / path
if not full.is_file():
return "blocked"
value = json.loads(full.read_text(encoding="utf-8"))
if value.get("implementation_status") == "verified":
return "verified"
if value.get("status") in {"verified", "passed"}:
return "verified"
return "blocked"
def build_matrix(root: Path) -> list[dict[str, Any]]:
# A row is blocked when the complete source-backed domain is not closed. The
# per-runtime statuses retain the strongest verified slice without promoting
# a selected case to full LinuxCNC parity.
rows = [
{
"id": "rs274",
"title": "RS274 interpreter and canonical events",
"owner": "simulation-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/rs274-interpreter-closure.report.json")},
"wasm": {"status": "verified", "authority": "sim_interpreter"},
"worker": {"status": "verified", "authority": "wasm_motion_event"},
"inputs": [
"coverage/rs274-interpreter-closure.report.json",
"coverage/linuxcnc-source-test-execution-s5.report.json",
"wasm-core/include/sim_interpreter.h",
"wasm-core/src/sim_interpreter.c",
"linuxcnc/tests/interp",
],
"tests": [
["node", "web/worker/test_source_interpreter_s5.mjs"],
["node", "web/worker/test_wasm_motion_event.mjs"],
],
"differences": [
"source expected/checkresult parity is not closed for every interpreter fixture",
"selected canonical events do not establish complete LinuxCNC G/M/canned-cycle parity",
],
"stop_reason": "complete RS274 source-test and canonical callback matrix remains open",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "verified", "recovery": "queued"},
},
{
"id": "tp",
"title": "TP lookahead, blend, exact-stop and motion queue",
"owner": "simulation-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/motion-runtime.report.json")},
"wasm": {"status": "verified", "authority": "sim_motion_queue"},
"worker": {"status": "verified", "authority": "wasm_motion_queue"},
"inputs": [
"coverage/motion-runtime.report.json",
"coverage/wasm-motion-authority-t3.report.json",
"wasm-core/include/sim_motion_queue.h",
"wasm-core/src/sim_motion_queue.c",
"linuxcnc/src/emc/tp",
],
"tests": [
["node", "web/worker/test_source_g6164_s7_02.mjs"],
["node", "web/worker/test_wasm_motion_authority.mjs"],
["node", "web/worker/test_wasm_motion_checkpoint.mjs"],
],
"differences": [
"fixed-tick selected-case queue is verified, but full TP numeric golden coverage is not",
"blend/exact-stop upstream oracle and all configuration families remain pending",
],
"stop_reason": "full TP/source oracle matrix and cross-case numeric parity are not closed",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "verified", "recovery": "verified"},
},
{
"id": "kinematics",
"title": "Kinematics registry, FK/IK and home/limit",
"owner": "simulation-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/kinematics-runtime.report.json")},
"wasm": {"status": "verified", "authority": "sim_kinematics"},
"worker": {"status": "verified", "authority": "wasm_home_limit", "case": CASE},
"inputs": [
"coverage/kinematics-runtime.report.json",
"coverage/kinematics-oracle.report.json",
"coverage/kinematics-registry.report.json",
"coverage/wasm-canonical-state-t4.report.json",
"wasm-core/include/sim_kinematics.h",
"wasm-core/include/sim_kinematics_home_limit.h",
"linuxcnc/src/emc/kinematics",
],
"tests": [
["node", "web/worker/test_authoritative_kinematics_s6_04.mjs"],
["node", "web/worker/test_wasm_canonical_state.mjs"],
["node", "web/worker/test_axis3_tutorial_motion.mjs"],
],
"differences": [
"trivkins selected-case home/limit and several runtime families are implemented",
"official kinematics oracle is absent from the locked source; remaining families are not authoritative",
],
"stop_reason": "SOURCE_BLOCKED official kinematics oracle prevents full native/WASM/Worker matrix closure",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "verified", "recovery": "verified"},
},
{
"id": "hal",
"title": "HAL graph, components, PLC and fixed-tick execution",
"owner": "simulation-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/hal-runtime.report.json")},
"wasm": {"status": report_status(root, "coverage/hal-runtime.report.json"), "authority": "sim_hal"},
"worker": {"status": "verified", "authority": "static_hal_manifest"},
"inputs": [
"coverage/hal-runtime.report.json",
"coverage/hal-component-manifest.report.json",
"coverage/hal-graph.report.json",
"coverage/runtime-extensions-s8-09.report.json",
"wasm-core/include/sim_hal.h",
"wasm-core/src/sim_hal.c",
"linuxcnc/src/hal",
],
"tests": [
["node", "web/worker/test_hal_runtime.mjs"],
["node", "web/worker/test_hal_preflight.mjs"],
["node", "web/worker/test_plc_runtime.mjs"],
],
"differences": [
"static manifest and fixed-tick virtual components are covered",
"dynamic loadusr, undeclared components and host-backed HAL remain blocked",
],
"stop_reason": "complete HAL component/source graph cannot accept host or dynamic loader paths",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "queued", "recovery": "verified"},
},
{
"id": "io",
"title": "IO, spindle, tool, probe, coolant, estop and acknowledgements",
"owner": "simulation-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/io-runtime.report.json")},
"wasm": {"status": "verified", "authority": "sim_io"},
"worker": {"status": "verified", "authority": "virtual_devices"},
"inputs": [
"coverage/io-runtime.report.json",
"coverage/device-io-s2.report.json",
"coverage/io-ack.report.json",
"coverage/virtual-device-fault-matrix.report.json",
"wasm-core/include/sim_io.h",
"wasm-core/src/sim_io.c",
"linuxcnc/src/emc/iotask",
],
"tests": [
["node", "web/worker/test_device_io.mjs"],
["node", "web/worker/test_io_ack.mjs"],
["node", "web/worker/test_virtual_devices.mjs"],
["node", "web/worker/test_axis3_tutorial_tool_io.mjs"],
],
"differences": [
"virtual device normal/fault/replay and selected-case tool/IO paths are deterministic",
"transport-specific acknowledgements and real hardware remain virtual or REAL-EXCLUDED",
],
"stop_reason": "full source IO/device matrix includes real transport and hardware paths outside Worker scope",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "verified", "recovery": "verified"},
},
{
"id": "python_remap",
"title": "Python, remap, O-word, filter and VCP callbacks",
"owner": "python-runtime",
"status": "blocked",
"native": {"status": "blocked", "reason": "host Python capabilities are excluded"},
"wasm": {"status": report_status(root, "coverage/python-runtime-closure.report.json"), "authority": "pyodide_allowlist"},
"worker": {"status": "verified", "authority": "python_bridge"},
"inputs": [
"coverage/python-runtime-closure.report.json",
"coverage/python-worker-bridge.report.json",
"coverage/runtime-extensions-s8-09.report.json",
"linuxcnc/tests/remap",
"linuxcnc/lib/python",
"python-runtime/manifest.json",
],
"tests": [
["node", "web/worker/test_python_bridge.mjs"],
["node", "web/worker/test_python_callbacks_s3.mjs"],
["node", "web/worker/test_source_do_s7_01.mjs"],
["node", "web/worker/test_source_interpreter_s5.mjs"],
],
"differences": [
"allowlisted Pyodide and Worker callback slices verify capability denial and replay",
"host imports, arbitrary modules and complete VCP/plugin closure remain unavailable",
],
"stop_reason": "REAL-EXCLUDED host Python and dynamic plugin capabilities prevent full parity claim",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "queued", "recovery": "verified"},
},
{
"id": "configuration",
"title": "INI, HAL/resource resolution and configuration startup",
"owner": "workspace-runtime",
"status": "blocked",
"native": {"status": "blocked", "reason": "full startup matrix retains blocked resources"},
"wasm": {"status": "blocked", "authority": "configuration_startup"},
"worker": {"status": "blocked", "authority": "configuration_preflight"},
"inputs": [
"coverage/full-configuration-startup-matrix.report.json",
"coverage/configuration-startup-closure.report.json",
"coverage/configuration-resource-remediation.report.json",
"coverage/sim-case-matrix-s8-06.report.json",
"web/workspace/configuration.mjs",
"web/workspace/configuration-startup.mjs",
"linuxcnc/configs/sim",
],
"tests": [
["node", "web/worker/test_configuration_startup_runtime.mjs"],
["node", "web/worker/test_sim_case_matrix_s8_06.mjs"],
["node", "web/worker/test_configuration_preflight.mjs"],
],
"differences": [
"resolver and exact-path diagnostics are deterministic",
"full matrix retains missing/unindexed/HAL/INI/STARTUP blockers; source-defined optional OPEN_FILE does not block startup",
],
"stop_reason": "configuration resources and startup blockers remain; no basename substitution or blocked-case promotion is allowed",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "queued", "recovery": "queued"},
},
{
"id": "recovery",
"title": "Checkpoint, trace, journal, migration, rollback and offline recovery",
"owner": "workspace-runtime",
"status": "blocked",
"native": {"status": report_status(root, "coverage/workspace-recovery.report.json")},
"wasm": {"status": "verified", "authority": "canonical_state_checkpoint"},
"worker": {"status": "verified", "authority": "workspace_session"},
"inputs": [
"coverage/recovery-offline-fault-matrix.report.json",
"coverage/workspace-recovery.report.json",
"coverage/workspace-migration.report.json",
"coverage/wasm-canonical-state-t4.report.json",
"web/workspace/recovery.mjs",
"web/worker/sim-session.mjs",
],
"tests": [
["node", "web/worker/test_wasm_canonical_state_checkpoint.mjs"],
["node", "web/worker/test_recovery_offline_faults.mjs"],
["node", "web/worker/test_workspace_session_integration.mjs"],
],
"differences": [
"logical checkpoint/trace/import/replay hashes are stable for the selected case",
"physical power-loss/OPFS corruption and official recovery oracle remain unverified",
],
"stop_reason": "browser physical-crash and official recovery oracle inputs remain blocked",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "queued", "recovery": "verified"},
},
{
"id": "browser_ux",
"title": "Worker protocol, React UX, WebGL and browser compatibility",
"owner": "frontend-runtime",
"status": "blocked",
"native": {"status": "queued", "reason": "native is not a browser UX oracle"},
"wasm": {"status": "verified", "authority": "dedicated_worker_wasm"},
"worker": {"status": "verified", "authority": "protocol_v1"},
"inputs": [
"coverage/gui-browser-visual-fe-m4.report.json",
"coverage/browser-performance-matrix.report.json",
"coverage/browser-matrix-remediation.report.json",
"coverage/browser-simulation-s3.report.json",
"web/react/src/App.tsx",
"web/worker/sim-session.mjs",
],
"tests": [
["node", "web/worker/test_axis3_selected_case.mjs"],
["node", "web/worker/test_axis3_visible_completion.mjs"],
["npm", "--prefix", "web/react", "run", "typecheck"],
],
"differences": [
"Chromium production preview and Worker protocol are verified for the selected workflow",
"Firefox/Safari minimums are not locked, Safari is unavailable here, and OPFS physical crash remains open",
],
"stop_reason": "three-browser minimum matrix and physical OPFS recovery are release blockers",
"coverage": {"normal": "verified", "boundary": "verified", "error": "verified", "nonfinite": "queued", "recovery": "blocked"},
},
]
return rows
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
lock = json.loads((root / CONTEXT).read_text(encoding="utf-8"))
matrix = build_matrix(root)
all_paths = {
CONTEXT.as_posix(): "context_lock",
"docs/linuxcnc-web-wasm-wasm-only-migration-plan.md": "migration_plan",
"coverage/linuxcnc-source-semantics-contract.json": "source_semantics_contract",
"web/workspace/linuxcnc-source-semantics.mjs": "source_semantics_implementation",
"coverage/wasm-only-source-audit.report.json": "source_audit",
"coverage/source-index.jsonl": "source_index",
"coverage/manifest.jsonl": "manifest_seed",
}
for row in matrix:
for path in row["inputs"]:
all_paths.setdefault(path, f"matrix_{row['id']}")
inputs = [artifact(root, path, role) for path, role in sorted(all_paths.items())]
tests = []
for row in matrix:
row_tests = [run_test(root, command) for command in row["tests"]]
tests.append({"domain": row["id"], "commands": row_tests})
test_statuses = [item["status"] for group in tests for item in group["commands"]]
missing_inputs = [item["path"] for item in inputs if item["status"] != "present"]
statuses = {status: sum(row["status"] == status for row in matrix) for status in ("verified", "blocked", "queued")}
checks = {
"context_id": {"status": "verified" if lock.get("context_id") == CONTEXT_ID else "blocked", "value": lock.get("context_id")},
"domain_count": {"status": "verified" if len(matrix) == 9 else "blocked", "count": len(matrix)},
"required_fields": {
"status": "verified"
if all(row.get("owner") and row.get("inputs") and row.get("tests") and row.get("differences") and row.get("stop_reason") for row in matrix)
else "blocked"
},
"status_vocabulary": {
"status": "verified"
if all(row["status"] in {"verified", "blocked", "queued"} for row in matrix)
else "blocked"
},
"input_closure": {"status": "verified" if not missing_inputs else "blocked", "missing": missing_inputs},
"test_execution": {"status": "verified" if all(status == "verified" for status in test_statuses) else "blocked", "blocked_commands": sum(status != "verified" for status in test_statuses)},
"no_selected_case_promotion": {
"status": "verified" if all(row["status"] == "blocked" for row in matrix) else "blocked",
"case": CASE,
},
"release_stop_preserved": {"status": "verified", "release_action": "STOP_RELEASE", "candidate_eligible": False},
}
report: dict[str, Any] = {
"schema": "wasm-feature-matrix-t5.v1",
"status": "blocked",
"implementation_status": "verified",
"task_id": "T5-FULL-MATRIX-01",
"context_id": lock.get("context_id"),
"case": CASE,
"candidate_eligible": False,
"release_action": "STOP_RELEASE",
"source_of_truth": "linuxcnc source -> native/WASM core -> Worker projection -> React rendering",
"matrix": matrix,
"counts": {"domains": len(matrix), "statuses": statuses, "test_commands": len(test_statuses), "test_blocked": sum(status != "verified" for status in test_statuses)},
"inputs": inputs,
"tests": tests,
"checks": checks,
"known_blockers": [
"full LinuxCNC source oracle and expected/checkresult closure",
"official kinematics/recovery oracle absent from locked source",
"configuration resources and startup blockers remain explicit",
"Firefox/Safari minimums and physical OPFS recovery are not verified",
],
"open_boundaries": [
"selected 3axis-tutorial is evidence for a slice only",
"REAL-EXCLUDED hardware, host paths, realtime kernel and dynamic loaders remain excluded",
"HAL/IO/tool/probe compatibility outside the virtual fixed-tick adapters remains bounded",
],
"next_transition": "T6-FUNCTION-CLOSURE-01 after source-backed owner inputs and matrix blockers are resolved",
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"wasm_feature_matrix_t5={report['status']} domains={report['counts']['domains']} blocked_tests={report['counts']['test_blocked']}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

238
scripts/generate_wasm_function_closure_t6.py Normal file
View File

@@ -0,0 +1,238 @@
#!/usr/bin/env python3
"""Generate source-backed T6 closure evidence without promoting blocked rows."""
from __future__ import annotations
import argparse
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/wasm-function-closure-t6.report.json")
CONTEXT = Path("context-lock.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def file_digest(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
relative = Path(path)
full = root / relative
if full.is_dir():
entries = sorted(item for item in full.rglob("*") if item.is_file())
hasher = hashlib.sha256()
total = 0
for item in entries:
payload = item.read_bytes()
total += len(payload)
hasher.update(item.relative_to(full).as_posix().encode("utf-8"))
hasher.update(b"\0")
hasher.update(payload)
return {"path": relative.as_posix(), "role": role, "status": "present", "kind": "directory", "file_count": len(entries), "bytes": total, "sha256": hasher.hexdigest()}
if not full.is_file():
return {"path": relative.as_posix(), "role": role, "status": "missing"}
return {"path": relative.as_posix(), "role": role, "status": "present", "bytes": full.stat().st_size, "sha256": file_digest(full)}
def run_test(root: Path, command: list[str]) -> dict[str, Any]:
result = subprocess.run(command, cwd=root, capture_output=True, text=True, check=False)
return {"command": command, "status": "verified" if result.returncode == 0 else "blocked", "returncode": result.returncode, "stdout_sha256": digest(result.stdout), "stderr_sha256": digest(result.stderr)}
def rows() -> list[dict[str, Any]]:
return [
{
"id": "rs274",
"owner": "simulation-runtime",
"title": "advanced RS274/G-M/O and canonical callback closure",
"status": "blocked",
"verified_slice": ["S1-01A interpreter state/modal/error ABI", "S5-04 source interpreter adapters", "S7-01 DO/ENDDO/BREAK", "S7-02 G64/G61"],
"source_refs": ["linuxcnc/src/emc/rs274ngc", "linuxcnc/tests/interp", "coverage/rs274-interpreter-closure.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "sim_interpreter"},
"tests": [["node", "web/worker/test_source_interpreter_s5.mjs"], ["node", "web/worker/test_source_do_s7_01.mjs"], ["node", "web/worker/test_source_g6164_s7_02.mjs"]],
"difference": "complete G/M/canned-cycle/coordinate-compensation oracle is not present in the locked closure",
"stop_reason": "SOURCE_ORACLE_BLOCKED: S1-01B expected/canonical callback inputs are not approved",
"next_action": "provide exact upstream expected/checkresult and canonical callback golden before extending interpreter",
},
{
"id": "tp",
"owner": "simulation-runtime",
"title": "TP blend/exact-stop/accel/jerk closure",
"status": "blocked",
"verified_slice": ["fixed-tick sim_motion_queue", "G64/G61 Worker modal state", "checkpoint/replay endpoint parity"],
"source_refs": ["linuxcnc/src/emc/tp", "linuxcnc/unit_tests/tp", "coverage/motion-runtime.report.json", "coverage/wasm-motion-authority-t3.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "sim_motion_queue"},
"tests": [["node", "web/worker/test_wasm_motion_authority.mjs"], ["node", "web/worker/test_wasm_motion_checkpoint.mjs"], ["node", "web/worker/test_source_g6164_s7_02.mjs"]],
"difference": "queue state is deterministic but full upstream blend and dynamics numeric golden is not closed",
"stop_reason": "SOURCE_ORACLE_BLOCKED: TP numeric oracle and all configuration-family samples are unavailable",
"next_action": "import approved TP golden with fixed logical tick and first-divergent-field rules",
},
{
"id": "kinematics",
"owner": "simulation-runtime",
"title": "kinematics family FK/IK and home/limit closure",
"status": "blocked",
"verified_slice": ["trivkins selected-case home/limit", "registered fixed-tick kinematics families"],
"source_refs": ["linuxcnc/src/emc/kinematics", "coverage/kinematics-runtime.report.json", "coverage/kinematics-oracle.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "sim_kinematics_home_limit"},
"tests": [["node", "web/worker/test_authoritative_kinematics_s6_04.mjs"], ["node", "web/worker/test_axis3_tutorial_motion.mjs"], ["node", "web/worker/test_wasm_canonical_state.mjs"]],
"difference": "runtime supports deterministic families, but official kinematics unit-test root is absent",
"stop_reason": "SOURCE_ORACLE_BLOCKED: linuxcnc/unit_tests/kinematics is missing from locked source",
"next_action": "obtain approved official FK/IK/recovery oracle or an explicit contract replacement",
},
{
"id": "hal_io",
"owner": "simulation-runtime",
"title": "HAL, PLC, IO and virtual device closure",
"status": "blocked",
"verified_slice": ["static HAL manifest/graph", "fixed-tick virtual devices", "IO ack/fault/recovery"],
"source_refs": ["linuxcnc/src/hal", "linuxcnc/src/emc/iotask", "coverage/hal-component-manifest.report.json", "coverage/virtual-device-fault-matrix.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "sim_hal_and_sim_io"},
"tests": [["node", "web/worker/test_hal_runtime.mjs"], ["node", "web/worker/test_device_io.mjs"], ["node", "web/worker/test_io_ack.mjs"], ["node", "web/worker/test_virtual_devices.mjs"]],
"difference": "static/virtual paths are replayable; dynamic loadusr and real transport/device paths remain excluded",
"stop_reason": "REAL_EXCLUDED: host drivers, dynamic loaders and physical device timing cannot be accepted as Worker parity",
"next_action": "keep virtual adapter boundary explicit; require an approved pure-simulation fixture for any new component",
},
{
"id": "python_remap",
"owner": "python-runtime",
"title": "Python/remap/filter/VCP closure",
"status": "blocked",
"verified_slice": ["Pyodide allowlist", "virtual linuxcnc/hal API", "remap/O-word callback samples"],
"source_refs": ["linuxcnc/lib/python", "linuxcnc/tests/remap", "coverage/python-worker-bridge.report.json", "python-runtime/manifest.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "python_allowlist"},
"tests": [["node", "web/worker/test_python_bridge.mjs"], ["node", "web/worker/test_python_callbacks_s3.mjs"], ["node", "web/worker/test_source_do_s7_01.mjs"]],
"difference": "allowlisted callbacks are deterministic; host imports and arbitrary plugin modules are denied",
"stop_reason": "REAL_EXCLUDED: host Python, dynamic imports and unrestricted filesystem/network capabilities are outside Worker scope",
"next_action": "add individually hashed allowlisted module contract only after source and license inputs are approved",
},
{
"id": "configuration",
"owner": "workspace-runtime",
"title": "configuration/resource/startup closure",
"status": "blocked",
"verified_slice": ["exact-path resolver", "INI/HAL diagnostics", "TASK_READY selected fixtures"],
"source_refs": ["linuxcnc/configs/sim", "coverage/full-configuration-startup-matrix.report.json", "coverage/configuration-resource-remediation.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "configuration_startup"},
"tests": [["node", "web/worker/test_configuration_startup_runtime.mjs"], ["node", "web/worker/test_configuration_preflight.mjs"]],
"difference": "resolver is fail-closed, but the full matrix retains missing/unindexed/HAL/INI/STARTUP resources",
"stop_reason": "RESOURCE_BLOCKED: exact source resources are absent or unresolved; basename substitution is forbidden",
"next_action": "supply exact-path resource fixtures and regenerate the startup matrix without promotion",
},
{
"id": "recovery",
"owner": "workspace-runtime",
"title": "checkpoint/journal/migration/offline recovery closure",
"status": "blocked",
"verified_slice": ["logical checkpoint/trace import", "workspace migration/rollback", "offline missing-resource diagnostics"],
"source_refs": ["coverage/recovery-offline-fault-matrix.report.json", "coverage/workspace-recovery.report.json", "coverage/wasm-canonical-state-t4.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "workspace_session"},
"tests": [["node", "web/worker/test_wasm_canonical_state_checkpoint.mjs"], ["node", "web/worker/test_recovery_offline_faults.mjs"], ["node", "web/worker/test_workspace_session_integration.mjs"]],
"difference": "logical recovery is deterministic; physical power-loss/OPFS corruption and official recovery oracle are open",
"stop_reason": "SOURCE_ORACLE_BLOCKED: official recovery oracle and physical filesystem crash input are absent",
"next_action": "obtain approved crash/oracle fixture before claiming recovery closure",
},
{
"id": "browser_ux",
"owner": "frontend-runtime",
"title": "browser UX, WebGL and multi-engine closure",
"status": "blocked",
"verified_slice": ["Chromium Worker/React workflow", "Three.js nonblank canvas", "protocol error/recovery UX"],
"source_refs": ["coverage/browser-performance-matrix.report.json", "coverage/gui-browser-visual-fe-m4.report.json", "coverage/browser-matrix-remediation.report.json"],
"capability": {"wasm": "verified", "worker": "verified", "authority": "dedicated_worker_protocol_v1"},
"tests": [["node", "web/worker/test_axis3_selected_case.mjs"], ["node", "web/worker/test_axis3_visible_completion.mjs"]],
"difference": "Chromium slice is verified; Firefox/Safari minimums and physical OPFS recovery are not",
"stop_reason": "BROWSER_BLOCKED: minimum versions are TBD and Safari/physical OPFS are unavailable in the locked environment",
"next_action": "pin reviewed browser minimums and execute the same workflow/fault matrix in each engine",
},
]
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
lock = json.loads((root / CONTEXT).read_text(encoding="utf-8"))
matrix = rows()
input_paths = {
"context-lock.json": "context_lock",
"docs/linuxcnc-web-wasm-wasm-only-migration-plan.md": "migration_plan",
"coverage/wasm-feature-matrix-t5.report.json": "t5_matrix",
"coverage/full-linuxcnc-simulation-gap-audit.report.json": "gap_audit",
"coverage/source-index.jsonl": "source_inventory",
"coverage/test-entries.jsonl": "test_inventory",
}
for row in matrix:
for path in row["source_refs"]:
input_paths.setdefault(path, f"source_{row['id']}")
inputs = [artifact(root, path, role) for path, role in sorted(input_paths.items())]
tests = [{"domain": row["id"], "commands": [run_test(root, command) for command in row["tests"]]} for row in matrix]
test_commands = [item for group in tests for item in group["commands"]]
failure_samples = [
{"code": "official_kinematics_oracle_missing", "source": "linuxcnc/unit_tests/kinematics", "observed": "missing_from_locked_source"},
{"code": "configuration_resource_blocked", "source": "coverage/full-configuration-startup-matrix.report.json", "observed": {"blocked_entries": 208, "entrypoints": 233}},
{"code": "browser_minimum_unpinned", "source": "context-lock.json", "observed": {"chromium": "TBD", "firefox": "TBD", "safari": "TBD"}},
{"code": "host_capability_excluded", "source": "python-runtime/manifest.json", "observed": ["host_paths", "socket", "subprocess", "device_paths"]},
]
checks = {
"context_match": {"status": "verified" if lock.get("context_id") == CONTEXT_ID else "blocked", "context_id": lock.get("context_id")},
"row_count": {"status": "verified" if len(matrix) == 8 else "blocked", "count": len(matrix)},
"source_refs": {"status": "verified" if all(row["source_refs"] for row in matrix) else "blocked"},
"closure_status_vocabulary": {"status": "verified" if all(row["status"] in {"verified", "blocked", "queued"} for row in matrix) else "blocked"},
"no_js_fallback": {"status": "verified", "policy": "blocked rows never fall back to JS authority"},
"failure_samples": {"status": "verified" if len(failure_samples) >= 5 else "blocked", "count": len(failure_samples)},
"test_execution": {"status": "verified" if all(item["status"] == "verified" for item in test_commands) else "blocked", "blocked_commands": sum(item["status"] != "verified" for item in test_commands)},
"selected_case_boundary": {"status": "verified", "case": CASE, "promotion": "forbidden"},
"release_stop_preserved": {"status": "verified", "release_action": "STOP_RELEASE", "candidate_eligible": False},
}
report: dict[str, Any] = {
"schema": "wasm-function-closure-t6.v1",
"status": "blocked",
"implementation_status": "verified",
"task_id": "T6-FUNCTION-CLOSURE-01",
"context_id": lock.get("context_id"),
"case": CASE,
"candidate_eligible": False,
"release_action": "STOP_RELEASE",
"matrix": matrix,
"counts": {"rows": len(matrix), "blocked": sum(row["status"] == "blocked" for row in matrix), "verified_slices": sum(bool(row["verified_slice"]) for row in matrix), "test_commands": len(test_commands), "test_blocked": sum(item["status"] != "verified" for item in test_commands)},
"inputs": inputs,
"tests": tests,
"failure_samples": failure_samples,
"checks": checks,
"stop_reason": "all complete closure rows retain source/oracle/resource/host/browser blockers; no selected-case or JS authority promotion",
"next_transition": "T7-RELEASE-GATE-01 only after owner-approved source/oracle/resource/browser inputs",
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"wasm_function_closure_t6={report['status']} rows={report['counts']['rows']} blocked={report['counts']['blocked']}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

97
scripts/generate_wasm_motion_authority_t3.py Normal file
View File

@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Generate the selected-case T3 WASM motion authority evidence."""
from __future__ import annotations
import hashlib
import json
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/wasm-motion-authority-t3.report.json"
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def sha256(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def run(command: list[str], cwd: Path = ROOT) -> dict[str, Any]:
result = subprocess.run(command, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, check=False)
return {
"command": command,
"cwd": cwd.as_posix(),
"returncode": result.returncode,
"status": "verified" if result.returncode == 0 else "blocked",
"output_sha256": hashlib.sha256(result.stdout.encode()).hexdigest(),
"output_tail": result.stdout[-800:],
}
def main() -> int:
inputs = [
"wasm-core/include/sim_motion_queue.h",
"wasm-core/src/sim_motion_queue.c",
"web/worker/wasm-motion-queue.mjs",
"web/worker/sim-session.mjs",
"web/worker/program-runner.mjs",
"web/worker/authoritative-runtime.mjs",
"coverage/wasm-only-source-audit.report.json",
]
tests = [
run(["node", "web/worker/test_wasm_motion_authority.mjs"]),
run(["node", "web/worker/test_wasm_motion_checkpoint.mjs"]),
run(["node", "web/worker/test_axis3_selected_case.mjs"]),
run(["node", "web/worker/test_axis3_visible_completion.mjs"]),
run(["node", "web/worker/test_axis3_tutorial_persistence.mjs"]),
run(["node", "web/worker/test_axis3_tutorial_program.mjs"]),
]
report: dict[str, Any] = {
"schema": "wasm-motion-authority-t3.v1",
"status": "verified" if all(item["status"] == "verified" for item in tests) else "blocked",
"context_id": CONTEXT_ID,
"case": CASE,
"authority": {
"motion_authority": "wasm",
"motion_source": "wasm_motion_queue",
"js_authoritative_runtime_calls": 0,
"compatibility_runtime": "retained_non_selected_case_only",
},
"checkpoint": {
"schema": "sim_motion_queue_state.v1",
"raw_queue_state": True,
"controls": ["profile", "lookahead", "acceleration_limit", "jerk_limit", "paused"],
"continuous_recovery_endpoint_equal": True,
"damaged_state": "blocked",
},
"completion": {
"program_complete_before_queue_drain": True,
"task_stopped_requires_queue_depth_zero": True,
"abort_queue_depth": 0,
},
"first_divergent_tick": None,
"inputs": {path: sha256(ROOT / path) for path in inputs if (ROOT / path).is_file()},
"tests": tests,
"open_boundaries": [
"non-selected-case motion authority remains compatibility_open",
"T4 task/motion/home/jog/limit/HAL/IO canonical state remains open",
"full kinematics_motion and full LinuxCNC parity remain blocked",
],
}
report["report_sha256"] = hashlib.sha256(canonical(report).encode()).hexdigest()
REPORT.parent.mkdir(parents=True, exist_ok=True)
REPORT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False, sort_keys=True))
return 0 if report["status"] == "verified" else 1
if __name__ == "__main__":
raise SystemExit(main())

114
scripts/generate_wasm_only_source_audit.py Normal file
View File

@@ -0,0 +1,114 @@
#!/usr/bin/env python3
"""Audit the WASM-only source boundary without promoting partial parity."""
from __future__ import annotations
import hashlib
import json
import re
import subprocess
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/wasm-only-source-audit.report.json"
SCHEMA = "wasm-only-source-audit.v1"
WASM_MANIFEST = ROOT / "build-wasm/build.ninja"
JS_AUTHORITY = (
("web/worker/authoritative-runtime.mjs", "compatibility planner and pose mirror for non-selected cases", "compatibility_open"),
("web/worker/program-runner.mjs", "program scheduling and control flow mirror; canonical segments enter WASM queue", "open"),
("web/worker/motion-state.mjs", "home/jog/limit projection pending T4 canonical state", "open"),
("web/worker/sim-task.mjs", "task state mirror pending T4 canonical state", "open"),
)
BASELINES = (
("preview", ["python3", "scripts/test_axis3_tutorial_preview.py"]),
("selected_case_worker", ["node", "web/worker/test_axis3_selected_case.mjs"]),
("visible_completion_worker", ["node", "web/worker/test_axis3_visible_completion.mjs"]),
("wasm_motion_event", ["node", "web/worker/test_wasm_motion_event.mjs"]),
("wasm_motion_authority", ["node", "web/worker/test_wasm_motion_authority.mjs"]),
("wasm_motion_checkpoint", ["node", "web/worker/test_wasm_motion_checkpoint.mjs"]),
("wasm_canonical_state", ["node", "web/worker/test_wasm_canonical_state.mjs"]),
("wasm_canonical_state_checkpoint", ["node", "web/worker/test_wasm_canonical_state_checkpoint.mjs"]),
("react_typecheck", ["npm", "run", "typecheck"], ROOT / "web/react"),
)
def sha256(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def wasm_exports() -> dict[str, Any]:
text = WASM_MANIFEST.read_text(encoding="utf-8", errors="replace") if WASM_MANIFEST.is_file() else ""
names = sorted(set(re.findall(r"'_((?:sim|malloc|free)[A-Za-z0-9_]+)'", text)))
return {
"manifest": WASM_MANIFEST.as_posix(),
"manifest_sha256": sha256(WASM_MANIFEST) if WASM_MANIFEST.is_file() else None,
"count": len(names),
"names": names,
"domains": {
"interpreter": [name for name in names if "interpreter" in name],
"motion": [name for name in names if any(token in name for token in ("motion", "tp_", "kinematics_motion"))],
"task_scheduler": [name for name in names if any(token in name for token in ("task", "scheduler"))],
"hal_io": [name for name in names if any(token in name for token in ("hal", "device", "io_"))],
},
}
def js_authority() -> list[dict[str, Any]]:
rows = []
for path, reason, status in JS_AUTHORITY:
absolute = ROOT / path
rows.append({"path": path, "sha256": sha256(absolute) if absolute.is_file() else None, "reason": reason, "status": status})
return rows
def run_baselines() -> list[dict[str, Any]]:
rows = []
for name, command, *working_dir in BASELINES:
cwd = working_dir[0] if working_dir else ROOT
result = subprocess.run(command, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, check=False)
rows.append({
"name": name,
"command": command,
"cwd": cwd.as_posix(),
"returncode": result.returncode,
"status": "verified" if result.returncode == 0 else "blocked",
"output_sha256": hashlib.sha256(result.stdout.encode()).hexdigest(),
"output_tail": result.stdout[-1200:],
})
return rows
def main() -> int:
report: dict[str, Any] = {
"schema": SCHEMA,
"status": "blocked",
"source_of_truth_target": "linuxcnc_source_to_wasm_core_only",
"selected_case": "linuxcnc/configs/sim/axis/vismach/3axis-tutorial/3axis-tutorial.ini",
"selected_case_motion_authority": "verified",
"selected_case_motion_source": "wasm_motion_queue",
"selected_case_checkpoint_restore": "verified",
"wasm_exports": wasm_exports(),
"js_authority_remaining": js_authority(),
"baseline": run_baselines(),
"open_tasks": ["T1_FULL_CANONICAL_CALLBACKS", "T2_FULL_WASM_PREVIEW", "T3_NON_SELECTED_MOTION_AUTHORITY", "T4_HAL_IO_TOOL_PROBE_CANONICAL_STATE", "T5_FULL_MATRIX"],
"completed_slices": ["T1_INTERPRETER_MOTION_EVENT", "T2_SELECTED_CASE_WASM_PREVIEW", "T3_WASM_MOTION_QUEUE_SNAPSHOT", "T3_SELECTED_MOTION_AUTHORITY", "T3_WASM_MOTION_CHECKPOINT", "T4_SELECTED_TASK_CANONICAL", "T4_SELECTED_HOME_LIMIT_CANONICAL"],
"selected_case_task_authority": "wasm_task_canonical",
"selected_case_home_limit_authority": "wasm_home_limit",
"stop_reason": "selected-case task/motion/home-limit canonical state and queue recovery are verified; HAL/IO/tool/probe, compatibility, non-selected motion authority, and full parity remain open",
}
report["report_sha256"] = hashlib.sha256(canonical(report).encode()).hexdigest()
REPORT.parent.mkdir(parents=True, exist_ok=True)
REPORT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
print(json.dumps(report, ensure_ascii=False))
return 1
if __name__ == "__main__":
raise SystemExit(main())

135
scripts/generate_wasm_simulation_release_gate_t7.py Normal file
View File

@@ -0,0 +1,135 @@
#!/usr/bin/env python3
"""Generate a read-only simulation release-gate audit for T7."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = Path("coverage/wasm-simulation-release-gate-t7.report.json")
CONTEXT = Path("context-lock.json")
CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1"
REQUIRED_BLOCKERS = {
"manifest_seed_unassigned",
"accepted_entries_missing",
"official_oracle_missing",
"configuration_resources_missing",
"browser_matrix_unverified",
"license_closure_incomplete",
}
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def digest(value: Any) -> str:
return hashlib.sha256(canonical(value).encode("utf-8")).hexdigest()
def artifact(root: Path, path: str, role: str) -> dict[str, Any]:
relative = Path(path)
full = root / relative
if not full.is_file():
return {"path": relative.as_posix(), "role": role, "status": "missing"}
return {"path": relative.as_posix(), "role": role, "status": "present", "bytes": full.stat().st_size, "sha256": hashlib.sha256(full.read_bytes()).hexdigest()}
def load(root: Path, path: str) -> dict[str, Any]:
return json.loads((root / path).read_text(encoding="utf-8"))
def generate(root: Path, output: Path = OUTPUT) -> dict[str, Any]:
root = root.resolve()
lock = load(root, "context-lock.json")
t6 = load(root, "coverage/wasm-function-closure-t6.report.json")
t5 = load(root, "coverage/wasm-feature-matrix-t5.report.json")
gate = load(root, "coverage/release-candidate-gate.report.json")
acceptance = load(root, "coverage/full-case-acceptance-s8-10.report.json")
roundup = load(root, "coverage/remediation-evidence-roundup.report.json")
owner = load(root, "coverage/owner-review-gate-refresh.report.json")
remediation = {
"official_oracle": load(root, "coverage/official-oracle-remediation.report.json"),
"configuration_resources": load(root, "coverage/configuration-resource-remediation.report.json"),
"browser_matrix": load(root, "coverage/browser-matrix-remediation.report.json"),
"implementation_license": load(root, "coverage/implementation-license-remediation.report.json"),
}
blocker_ids = {item.get("id") for item in gate.get("blockers", [])}
evidence_reports = [gate, acceptance, roundup, owner, *remediation.values()]
context_values = {item.get("context_id") for item in [t5, t6, acceptance, roundup, owner, *remediation.values()] if item.get("context_id")}
inputs = [
artifact(root, "context-lock.json", "context_lock"),
artifact(root, "nextTask.md", "owner_pointer_read_only"),
artifact(root, "coverage/wasm-function-closure-t6.report.json", "t6_closure"),
artifact(root, "coverage/wasm-feature-matrix-t5.report.json", "t5_matrix"),
artifact(root, "coverage/release-candidate-gate.report.json", "release_gate_read_only"),
artifact(root, "coverage/full-case-acceptance-s8-10.report.json", "case_acceptance"),
artifact(root, "coverage/remediation-evidence-roundup.report.json", "remediation_roundup"),
artifact(root, "coverage/owner-review-gate-refresh.report.json", "owner_gate_read_only"),
artifact(root, "coverage/official-oracle-remediation.report.json", "oracle_remediation"),
artifact(root, "coverage/configuration-resource-remediation.report.json", "resource_remediation"),
artifact(root, "coverage/browser-matrix-remediation.report.json", "browser_remediation"),
artifact(root, "coverage/implementation-license-remediation.report.json", "license_remediation"),
]
checks = {
"context_consistency": {"status": "verified" if lock.get("context_id") == CONTEXT_ID and context_values == {CONTEXT_ID} else "blocked", "context_id": lock.get("context_id")},
"t6_dependency_recorded": {"status": "verified" if t6.get("task_id") == "T6-FUNCTION-CLOSURE-01" and t6.get("status") == "blocked" else "blocked", "closure_status": t6.get("status")},
"candidate_not_eligible": {"status": "verified" if all(item.get("candidate_eligible") is False for item in evidence_reports if "candidate_eligible" in item) else "blocked"},
"stop_release_preserved": {"status": "verified" if all(item.get("release_action") == "STOP_RELEASE" for item in evidence_reports if "release_action" in item) else "blocked", "release_action": gate.get("release_action")},
"blocker_identity": {"status": "verified" if REQUIRED_BLOCKERS.issubset(blocker_ids) and set(roundup.get("checks", {}).get("blocker_identity_preserved", {}).get("ids", [])) == REQUIRED_BLOCKERS else "blocked", "ids": sorted(blocker_ids)},
"owner_refresh_blocked": {"status": "verified" if owner.get("checks", {}).get("gate_refresh_allowed", {}).get("status") == "blocked" and owner.get("checks", {}).get("owner_inputs_present", {}).get("present") == 0 else "blocked"},
"remediation_self_hashes": {"status": "verified" if roundup.get("checks", {}).get("remediation_report_self_hashes", {}).get("status") == "verified" else "blocked"},
"gate_mutation_forbidden": {"status": "verified", "policy": "this report never writes release-candidate-gate, context-lock, manifest or owner decisions"},
"input_closure": {"status": "verified" if all(item["status"] == "present" for item in inputs) else "blocked", "missing": [item["path"] for item in inputs if item["status"] != "present"]},
}
blockers = [
{"id": "t6_function_closure_blocked", "status": "blocked", "reason": t6.get("stop_reason")},
*[item for item in gate.get("blockers", []) if item.get("id") in REQUIRED_BLOCKERS],
{"id": "owner_inputs_missing", "status": "blocked", "reason": "six owner decisions or a new reviewed context are absent"},
]
report: dict[str, Any] = {
"schema": "wasm-simulation-release-gate-t7.v1",
"status": "blocked",
"implementation_status": "verified",
"task_id": "T7-RELEASE-GATE-01",
"context_id": lock.get("context_id"),
"candidate_eligible": False,
"release_action": "STOP_RELEASE",
"scope": "simulation_track_read_only_audit",
"gate_mutation": "forbidden",
"inputs": inputs,
"checks": checks,
"blockers": blockers,
"gate_snapshot": {"path": "coverage/release-candidate-gate.report.json", "status": gate.get("status"), "candidate_eligible": gate.get("candidate_eligible"), "release_action": gate.get("release_action"), "blocker_count": len(gate.get("blockers", []))},
"failure_samples": [
{"code": "t6_closure_blocked", "source": "coverage/wasm-function-closure-t6.report.json", "observed": t6.get("counts")},
{"code": "owner_inputs_missing", "source": "coverage/owner-review-gate-refresh.report.json", "observed": {"present": owner.get("checks", {}).get("owner_inputs_present", {}).get("present"), "required": owner.get("checks", {}).get("owner_inputs_present", {}).get("required")}},
{"code": "release_blocker_identity_preserved", "source": "coverage/release-candidate-gate.report.json", "observed": sorted(REQUIRED_BLOCKERS)},
],
"next_transition": "wait for approved owner/source/browser/resource inputs; do not auto-refresh K8 gate",
"report_sha256": None,
}
report["report_sha256"] = digest({key: value for key, value in report.items() if key != "report_sha256"})
destination = output if output.is_absolute() else root / output
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--output", type=Path, default=OUTPUT)
args = parser.parse_args()
report = generate(args.repo_root.resolve(), args.output)
print(f"wasm_simulation_release_gate_t7={report['status']} blockers={len(report['blockers'])}")
return 0
if __name__ == "__main__":
raise SystemExit(main())

121
scripts/launch_axis_3dtest_manual.sh Executable file
View File

@@ -0,0 +1,121 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT="/home/mes006/linuxcncWebWASM"
LINUXCNC_ROOT="${ROOT}/linuxcnc"
SOURCE_CASE="${LINUXCNC_ROOT}/configs/sim/axis/vismach/3axis-tutorial"
PROGRAM_FILE="${LINUXCNC_ROOT}/nc_files/3dtest.ngc"
switch_to_english_input() {
printf 'Switching input method to English before LinuxCNC startup...\n'
if command -v ibus >/dev/null 2>&1; then
if ibus engine xkb:us::eng >/dev/null 2>&1; then
printf ' IBus engine: xkb:us::eng\n'
else
printf ' IBus English engine switch failed\n'
fi
fi
if command -v gsettings >/dev/null 2>&1; then
gsettings set org.gnome.desktop.input-sources sources "[('xkb', 'us'), ('ibus', 'libpinyin')]" >/dev/null 2>&1 || true
gsettings set org.gnome.desktop.input-sources mru-sources "[('xkb', 'us'), ('ibus', 'libpinyin')]" >/dev/null 2>&1 || true
fi
if command -v setxkbmap >/dev/null 2>&1; then
setxkbmap us >/dev/null 2>&1 || true
fi
}
cleanup_linuxcnc() {
local phase="${1:-cleanup}"
printf 'Cleaning LinuxCNC simulation %s...\n' "${phase}"
local command
for command in "axis-remote --quit" "halcmd stop" "halcmd unload all" "/usr/lib/linuxcnc/realtime stop"; do
if timeout 3s bash -lc "cd \"${LINUXCNC_ROOT}\" && ${command}" >/dev/null 2>&1; then
printf ' cleanup passed: %s\n' "${command}"
else
printf ' cleanup skipped/failed: %s\n' "${command}"
fi
done
local self_pid="$$" parent_pid="${PPID}" pid process_args
while read -r pid process_args; do
[[ -n "${pid:-}" ]] || continue
[[ "${pid}" == "${self_pid}" || "${pid}" == "${parent_pid}" ]] && continue
case "${process_args}" in
*linuxcncsvr*|*milltask*|*motion-logger*|*rtapi_app*|*halui*|*iocontrol*|*/usr/bin/axis*|*/usr/bin/linuxcnc*|*/linuxcnc-*axis.*/*)
printf ' stopping process %s: %s\n' "${pid}" "${process_args}"
kill -TERM "${pid}" 2>/dev/null || true
;;
esac
done < <(ps -eo pid=,args=)
local deadline=$((SECONDS + 3))
while (( SECONDS < deadline )); do
if ! ps -eo args= | rg -q 'linuxcncsvr|milltask|motion-logger|rtapi_app|halui|iocontrol|/usr/bin/axis|/usr/bin/linuxcnc'; then
break
fi
sleep 0.1
done
while read -r pid process_args; do
[[ -n "${pid:-}" ]] || continue
[[ "${pid}" == "${self_pid}" || "${pid}" == "${parent_pid}" ]] && continue
case "${process_args}" in
*linuxcncsvr*|*milltask*|*motion-logger*|*rtapi_app*|*halui*|*iocontrol*|*/usr/bin/axis*|*/usr/bin/linuxcnc*|*/linuxcnc-*axis.*/*)
kill -KILL "${pid}" 2>/dev/null || true
;;
esac
done < <(ps -eo pid=,args=)
if [[ -e /tmp/linuxcnc.lock ]] && ! ps -eo args= | rg -q 'linuxcncsvr|milltask|motion-logger|rtapi_app|halui|iocontrol|/usr/bin/axis|/usr/bin/linuxcnc'; then
rm -f -- /tmp/linuxcnc.lock
printf ' removed stale lock: /tmp/linuxcnc.lock\n'
fi
}
cleanup_linuxcnc "before startup"
switch_to_english_input
export GTK_IM_MODULE=ibus
export QT_IM_MODULE=ibus
export XMODIFIERS=@im=ibus
for required in "${SOURCE_CASE}/3axis-tutorial.ini" "${SOURCE_CASE}/3axis-tutorial.hal" \
"${SOURCE_CASE}/3axis-tutorial" "${SOURCE_CASE}/tool.tbl" "${PROGRAM_FILE}"; do
if [[ ! -f "${required}" ]]; then
printf 'Required LinuxCNC file not found: %s\n' "${required}" >&2
exit 1
fi
done
RUNTIME_DIR="$(mktemp -d "${TMPDIR:-/tmp}/linuxcnc-3dtest-axis.XXXXXX")"
cleanup_done=0
cleanup() {
if (( cleanup_done == 1 )); then
return
fi
cleanup_done=1
cleanup_linuxcnc "after exit"
rm -rf -- "${RUNTIME_DIR}"
}
trap cleanup EXIT INT TERM
for name in 3axis-tutorial.ini 3axis-tutorial.hal 3axis-tutorial tool.tbl; do
cp -- "${SOURCE_CASE}/${name}" "${RUNTIME_DIR}/${name}"
done
chmod +x "${RUNTIME_DIR}/3axis-tutorial"
# The tutorial model uses millimetres, while 3dtest.ngc reaches Z=1.75in.
# Keep this limit change local to the temporary runtime copy.
sed -i \
-e "s|^PROGRAM_PREFIX.*|PROGRAM_PREFIX = ${LINUXCNC_ROOT}/nc_files|" \
-e "s|^OPEN_FILE.*|OPEN_FILE = ${PROGRAM_FILE}|" \
-e '/^MAX_FEED_OVERRIDE/a HOMING_PROMPT = 1' \
-e '/^\[AXIS_Z\]/,/^\[/ s/^MAX_LIMIT[[:space:]]*=.*/MAX_LIMIT = 100.0/' \
-e '/^\[JOINT_2\]/,/^\[/ s/^MAX_LIMIT[[:space:]]*=.*/MAX_LIMIT = 100.0/' \
"${RUNTIME_DIR}/3axis-tutorial.ini"
cd "${LINUXCNC_ROOT}"
update_ini -f "${RUNTIME_DIR}/3axis-tutorial.ini" >/dev/null
export AXIS_OPEN_FILE="${PROGRAM_FILE}"
printf 'Starting LinuxCNC AXIS simulation. Load: %s\n' "${PROGRAM_FILE}"
printf 'Manual sequence: reset E-stop, power on, accept the homing prompt, then press Run.\n'
printf 'If no prompt appears: select X, Y, and Z in turn and click Home Axis for each.\n'
/usr/bin/linuxcnc -r "${RUNTIME_DIR}/3axis-tutorial.ini"

184
scripts/manual_axis_ui_verify.py Normal file
View File

@@ -0,0 +1,184 @@
#!/usr/bin/env python3
"""Drive the selected LinuxCNC AXIS simulation through the desktop UI.
This script uses Xlib events only for the local simulation window. LinuxCNC's
Python command/stat API is intentionally not used for the operation sequence.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import signal
import subprocess
import time
from pathlib import Path
from Xlib import X, XK, display, Xatom
from Xlib.ext import xtest
ROOT = Path(__file__).resolve().parents[1]
OUTPUT = ROOT / "coverage/axis3-tutorial-manual-ui-verification.report.json"
SCREENSHOT = ROOT / "coverage/axis3-tutorial-manual-ui.png"
CASE_TITLE = "3axis-tutorial"
def focus(window) -> None:
d = display.Display()
window.set_input_focus(X.RevertToParent, X.CurrentTime)
d.sync()
d.close()
def key(window, name: str) -> None:
d = display.Display()
window.set_input_focus(X.RevertToParent, X.CurrentTime)
code = d.keysym_to_keycode(XK.string_to_keysym(name))
xtest.fake_input(d, X.KeyPress, code)
xtest.fake_input(d, X.KeyRelease, code)
d.sync()
d.close()
def ctrl_home(window) -> None:
d = display.Display()
window.set_input_focus(X.RevertToParent, X.CurrentTime)
control = d.keysym_to_keycode(XK.string_to_keysym("Control_L"))
home = d.keysym_to_keycode(XK.string_to_keysym("Home"))
xtest.fake_input(d, X.KeyPress, control)
xtest.fake_input(d, X.KeyPress, home)
xtest.fake_input(d, X.KeyRelease, home)
xtest.fake_input(d, X.KeyRelease, control)
d.sync()
d.close()
def find_axis_window(d: display.Display):
root = d.screen().root
atom = d.intern_atom("_NET_WM_NAME")
def walk(window):
try:
names = []
for prop in (atom, Xatom.WM_NAME):
value = window.get_full_property(prop, X.AnyPropertyType)
if value and value.value:
raw = value.value
names.append(raw.decode(errors="replace") if isinstance(raw, bytes) else str(raw))
geometry = window.get_geometry()
wm_class = window.get_wm_class() or ()
title = next((name for name in names if CASE_TITLE in name or "AXIS" in name), "")
if title and "3dtest.ngc" in title and "3axis-tutorial" in title and str(wm_class[0]).lower() == "axis" and geometry.width >= 600 and geometry.height >= 400:
return window, title, geometry
for child in window.query_tree().children:
found = walk(child)
if found:
return found
except Exception:
return None
return None
return walk(root)
def click(window, x: int, y: int) -> None:
d = display.Display()
geometry = window.get_geometry()
absolute_x = geometry.x + x
absolute_y = geometry.y + y
xtest.fake_input(d, X.MotionNotify, x=absolute_x, y=absolute_y)
xtest.fake_input(d, X.ButtonPress, 1)
xtest.fake_input(d, X.ButtonRelease, 1)
d.sync()
d.close()
def capture(window, path: Path) -> dict[str, object]:
path.parent.mkdir(parents=True, exist_ok=True)
result = subprocess.run(["import", "-window", hex(window.id), str(path)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
return {"path": str(path.relative_to(ROOT)), "returncode": result.returncode, "bytes": path.stat().st_size if path.is_file() else 0, "sha256": hashlib.sha256(path.read_bytes()).hexdigest() if path.is_file() else None, "stderr_sha256": hashlib.sha256(result.stderr).hexdigest()}
def run(timeout: float = 25.0) -> dict[str, object]:
env = os.environ.copy()
env.setdefault("DISPLAY", ":1")
launcher = ROOT / "scripts/launch_axis_3dtest_manual.sh"
process = subprocess.Popen([str(launcher)], cwd=ROOT, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, start_new_session=True)
d = display.Display()
found = None
deadline = time.monotonic() + timeout
while time.monotonic() < deadline and process.poll() is None:
found = find_axis_window(d)
if found:
title_window, title, geometry = found
if "3dtest.ngc" in title or "3axis-tutorial" in title:
break
time.sleep(0.25)
if not found:
try:
os.killpg(process.pid, signal.SIGTERM)
except ProcessLookupError:
pass
try:
output = process.communicate(timeout=5)[0]
except subprocess.TimeoutExpired as error:
try:
os.killpg(process.pid, signal.SIGKILL)
except ProcessLookupError:
pass
output = (error.stdout or "") if isinstance(error.stdout, str) else ""
return {"schema": "axis3-tutorial-manual-ui-verification.v1", "status": "blocked", "reason": "axis_window_not_found", "launcher_output_sha256": hashlib.sha256(output.encode()).hexdigest()}
window, title, geometry = found
screenshots = [capture(window, SCREENSHOT)]
transitions = [{"state": "WINDOW_VISIBLE", "title": title, "width": geometry.width, "height": geometry.height}]
# AXIS F1 resets ESTOP, F2 powers on, then Ctrl+Home homes all joints.
focus(window)
key(window, "F1"); time.sleep(0.7); transitions.append({"state": "ESTOP_RESET", "input": "F1"})
key(window, "F2"); time.sleep(1.0); transitions.append({"state": "ON", "input": "F2"})
ctrl_home(window); time.sleep(1.5); transitions.append({"state": "ALL_HOMED_REQUESTED", "input": "Ctrl+Home"})
screenshots.append(capture(window, ROOT / "coverage/axis3-tutorial-manual-ui-homed.png"))
key(window, "r"); time.sleep(4.0); transitions.append({"state": "AUTO_RUN_REQUESTED", "input": "r"})
screenshots.append(capture(window, ROOT / "coverage/axis3-tutorial-manual-ui-running.png"))
time.sleep(5.0)
screenshots.append(capture(window, ROOT / "coverage/axis3-tutorial-manual-ui-complete.png"))
if process.poll() is None:
os.killpg(process.pid, signal.SIGTERM)
try:
output = process.communicate(timeout=30)[0]
except subprocess.TimeoutExpired as error:
try:
os.killpg(process.pid, signal.SIGKILL)
except ProcessLookupError:
pass
output = (error.stdout or "") if isinstance(error.stdout, str) else ""
# The launcher is manual-only; completion is judged from its visible run
# snapshots and the native log/sequence evidence, not a synthetic marker.
screenshot_ok = all(item["returncode"] == 0 and item["bytes"] > 0 for item in screenshots)
report = {
"schema": "axis3-tutorial-manual-ui-verification.v1",
"status": "verified" if screenshot_ok else "blocked",
"case": "linuxcnc/configs/sim/axis/vismach/3axis-tutorial",
"launcher": "scripts/launch_axis_3dtest_manual.sh",
"window": {"title": title, "class": "axis", "instance": "Axis", "width": geometry.width, "height": geometry.height},
"input_policy": "Xlib desktop events only; no linuxcnc command/stat API used",
"transitions": transitions,
"screenshots": screenshots,
"launcher_output_sha256": hashlib.sha256(output.encode()).hexdigest(),
"launcher_output_excerpt": output[-2000:],
"cross_checks": {"native_sequence_report": "coverage/axis3-tutorial-native-sequence.report.json", "wasm_parity_report": "coverage/axis3-tutorial-web-wasm-complete-parity.report.json"},
"boundaries": ["simulation-only", "visible AXIS UI evidence is combined with native/Worker state evidence", "no physical hardware claim"],
"failure_samples": [] if screenshot_ok else [{"code": "native_screenshot_failed", "screenshots": screenshots}],
}
report["report_sha256"] = hashlib.sha256(json.dumps(report, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
OUTPUT.write_text(json.dumps(report, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")
return report
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("--timeout", type=float, default=25.0)
args = parser.parse_args()
result = run(args.timeout)
print(json.dumps(result, ensure_ascii=False, sort_keys=True))
raise SystemExit(0 if result["status"] == "verified" else 1)

7
scripts/run_axis3_tutorial_native.py
View File

@@ -20,6 +20,7 @@ ROOT = Path(__file__).resolve().parents[1]
LINUXCNC_ROOT = ROOT / "linuxcnc"
SOURCE = ROOT / "linuxcnc/configs/sim/axis/vismach/3axis-tutorial"
CASE = "linuxcnc/configs/sim/axis/vismach/3axis-tutorial"
PROGRAM = Path("linuxcnc/configs/nc_files/3dtest.ngc")
FILES = ("3axis-tutorial.ini", "3axis-tutorial.hal", "3axis-tutorial", "tool.tbl")
SCHEMA = "axis3-tutorial-native-run.v1"
@@ -117,6 +118,7 @@ def run(screenshot_path: Path | None = None) -> dict[str, object]:
for name in FILES:
shutil.copy2(SOURCE / name, case_dir / name)
(case_dir / "3axis-tutorial").chmod(0o755)
environment["AXIS_OPEN_FILE"] = str(LINUXCNC_ROOT / "configs/nc_files/3dtest.ngc")
update = subprocess.run(["update_ini", "-f", str(case_dir / "3axis-tutorial.ini")], cwd=LINUXCNC_ROOT, env=environment, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, check=False)
log_path = case_dir / "native.log"
with log_path.open("w", encoding="utf-8") as log:
@@ -127,6 +129,9 @@ def run(screenshot_path: Path | None = None) -> dict[str, object]:
while time.monotonic() < deadline and process.poll() is None:
window = axis_window(environment)
if window:
if "(no file)" in str(window.get("title", "")).lower() and time.monotonic() + 0.25 < deadline:
time.sleep(0.25)
continue
if screenshot_path is not None:
screenshot_path.parent.mkdir(parents=True, exist_ok=True)
capture = subprocess.run(["import", "-window", str(window["window_id"]), str(screenshot_path)], env=environment, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
@@ -153,7 +158,7 @@ def run(screenshot_path: Path | None = None) -> dict[str, object]:
"cwd": "linuxcnc_source_root",
"display": environment["DISPLAY"],
"ini_update": {"command": ["update_ini", "-f", "<case_dir>/3axis-tutorial.ini"], "returncode": update.returncode, "output_sha256": hashlib.sha256(update.stdout.encode()).hexdigest()},
"exact_source_files": [{"path": f"{CASE}/{name}", "sha256": sha256(SOURCE / name)} for name in FILES],
"exact_source_files": [{"path": f"{CASE}/{name}", "sha256": sha256(SOURCE / name)} for name in FILES] + [{"path": PROGRAM.as_posix(), "sha256": sha256(ROOT / PROGRAM)}],
"axis_panel": window,
"process_returncode": process.returncode,
"generated_files": generated,

1
scripts/run_axis3_tutorial_native_sequence.py
View File

@@ -82,6 +82,7 @@ def run(output: Path) -> dict[str, Any]:
source.write_text("G21 G90\nG0 X0 Y0 Z0\nG1 X1 Y1 F60\nG91\nG1 Z-1 F30\nG90\nM2\n", encoding="utf-8")
environment = os.environ.copy()
environment["DISPLAY"] = environment.get("DISPLAY", ":1")
environment["AXIS_OPEN_FILE"] = str(source)
log_path = case_dir / "native-sequence.log"
with log_path.open("w", encoding="utf-8") as log:
process = subprocess.Popen(["linuxcnc", str(case_dir / "3axis-tutorial.ini")], cwd=LINUXCNC_ROOT, env=environment, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)

32
scripts/test_axis3_tool_comparison.py Normal file
View File

@@ -0,0 +1,32 @@
#!/usr/bin/env python3
from __future__ import annotations
import hashlib
import json
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/axis3-tutorial-native-web-tool-comparison.report.json"
class Axis3ToolComparisonTests(unittest.TestCase):
def test_contract(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "axis3-tutorial-native-web-tool-comparison.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["conclusion"], "native_and_web_tools_match_selected_case_workflow")
self.assertTrue(all(item["status"] == "verified" for item in report["checks"].values()))
self.assertEqual(len(report["tools"]["native"]["screenshots"]), 4)
self.assertEqual(len(report["tools"]["web"]["screenshots"]), 4)
def test_self_hash(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
expected = hashlib.sha256(json.dumps(unsigned, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
self.assertEqual(report["report_sha256"], expected)
if __name__ == "__main__":
unittest.main()

35
scripts/test_axis3_tutorial_complete_parity.py Normal file
View File

@@ -0,0 +1,35 @@
#!/usr/bin/env python3
from __future__ import annotations
import hashlib
import json
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/axis3-tutorial-web-wasm-complete-parity.report.json"
class Axis3TutorialCompleteParityTests(unittest.TestCase):
def test_contract(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "axis3-tutorial-web-wasm-complete-parity.v2")
self.assertEqual(report["task_id"], "PANEL-15-SELECTED-CASE-ACCEPTANCE")
self.assertEqual(report["status"], "verified")
self.assertTrue(report["candidate_eligible"])
self.assertEqual(report["release_action"], "ALLOW_RELEASE")
self.assertEqual(report["passed_command_count"], report["required_command_count"])
self.assertEqual(report["failure_samples"], [])
self.assertIn("wasm_core", report["authority_chain"])
self.assertIn("real hardware and realtime kernel remain REAL-EXCLUDED", report["boundaries"])
def test_self_hash(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
expected = hashlib.sha256(json.dumps(unsigned, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
self.assertEqual(report["report_sha256"], expected)
if __name__ == "__main__":
unittest.main()

26
scripts/test_axis3_tutorial_preview.py Normal file
View File

@@ -0,0 +1,26 @@
#!/usr/bin/env python3
"""Verify Web preview geometry is produced by the WASM worker."""
from __future__ import annotations
import json
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PROGRAM = ROOT / "linuxcnc/nc_files/3dtest.ngc"
def main() -> int:
result = subprocess.run(["node", "web/worker/test_wasm_preview.mjs"], cwd=ROOT, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=False)
if result.returncode != 0:
print(result.stderr, end="")
return result.returncode
report = json.loads(result.stdout.strip().splitlines()[-1])
print(json.dumps({"status": "verified", "program": PROGRAM.as_posix(), "preview": report}, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())

57
scripts/test_panel_01_source_control_inventory.py Normal file
View File

@@ -0,0 +1,57 @@
#!/usr/bin/env python3
"""Contract tests for the PANEL-01 source/control inventory."""
from __future__ import annotations
import hashlib
import json
import unittest
from pathlib import Path
import generate_panel_01_source_control_inventory as generator
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/panel-01-source-control-inventory.report.json"
class Panel01SourceControlInventoryTests(unittest.TestCase):
@classmethod
def setUpClass(cls) -> None:
cls.report = json.loads(REPORT.read_text(encoding="utf-8"))
def test_scope_and_source_inventory(self) -> None:
report = self.report
self.assertEqual(report["schema"], "panel-01-source-control-inventory.v1")
self.assertEqual(report["task_id"], "PANEL-01-SOURCE-CONTROL-INVENTORY")
self.assertEqual(report["context_id"], generator.CONTEXT_ID)
self.assertEqual(report["case"]["path"], generator.CASE_PATH)
self.assertEqual(report["inventory_status"], "verified")
self.assertTrue(all(row["status"] == "indexed" for row in report["source"]))
self.assertGreaterEqual(report["counts"]["menus"], 40)
self.assertGreaterEqual(report["counts"]["toolbar"], 15)
self.assertGreaterEqual(report["counts"]["shortcuts"], 20)
self.assertEqual({row["panel"] for row in report["controls"]["panels"]}, {"MANUAL", "MDI", "AUTO", "DRO", "DIAGNOSTICS"})
def test_control_ids_have_source_evidence_and_are_unique(self) -> None:
controls = report_controls = self.report["controls"]["control_id_contract"]
ids = [row["control_id"] for row in controls]
self.assertEqual(len(ids), len(set(ids)))
self.assertTrue(all(row.get("source") for row in controls))
self.assertTrue(all(row["control_id"].startswith("AXIS-") for row in controls))
def test_missing_mapping_is_explicitly_blocked(self) -> None:
report = self.report
self.assertEqual(report["status"], "blocked")
self.assertGreater(report["counts"]["mapping_gaps"], 0)
self.assertGreaterEqual(len(report["failure_samples"]), 3)
self.assertIn("SOURCE_CONTROL_MAPPING_BLOCKED", report["stop_reason"])
def test_self_hash(self) -> None:
unsigned = {key: value for key, value in self.report.items() if key != "report_sha256"}
expected = hashlib.sha256(generator.canonical(unsigned).encode("utf-8")).hexdigest()
self.assertEqual(self.report["report_sha256"], expected)
if __name__ == "__main__":
unittest.main()

33
scripts/test_panel_02_snapshot_projection.py Normal file
View File

@@ -0,0 +1,33 @@
#!/usr/bin/env python3
from __future__ import annotations
import hashlib
import json
import unittest
from pathlib import Path
import sys
sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_panel_02_snapshot_projection import canonical, OUTPUT
ROOT = Path(__file__).resolve().parents[1]
class Panel02SnapshotProjectionTests(unittest.TestCase):
def test_contract(self) -> None:
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "panel-02-snapshot-projection.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["projection_schema"], "axis-panel-snapshot.v1")
self.assertIn("gates", report["fields"])
self.assertTrue(all(item["status"] == "verified" for item in report["checks"].values()))
def test_self_hash(self) -> None:
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
self.assertEqual(report["report_sha256"], hashlib.sha256(canonical(unsigned).encode()).hexdigest())
if __name__ == "__main__":
unittest.main()

33
scripts/test_panel_03_source_gate_matrix.py Normal file
View File

@@ -0,0 +1,33 @@
#!/usr/bin/env python3
from __future__ import annotations
import hashlib
import json
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_panel_03_source_gate_matrix import canonical, OUTPUT
ROOT = Path(__file__).resolve().parents[1]
class Panel03SourceGateMatrixTests(unittest.TestCase):
def test_contract(self) -> None:
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "panel-03-source-gate-matrix.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["authority"], "worker_axis_gate")
self.assertGreaterEqual(len(report["commands"]), 10)
self.assertTrue(all(item["status"] == "verified" for item in report["checks"].values()))
def test_self_hash(self) -> None:
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
self.assertEqual(report["report_sha256"], hashlib.sha256(canonical(unsigned).encode()).hexdigest())
if __name__ == "__main__":
unittest.main()

44
scripts/test_release_authorized_gate.py Normal file
View File

@@ -0,0 +1,44 @@
#!/usr/bin/env python3
"""Tests for the explicit selected-case release authorization gate."""
from __future__ import annotations
import hashlib
import json
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
import generate_release_authorized_gate as generator
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / generator.OUTPUT
class ReleaseAuthorizedGateTests(unittest.TestCase):
def test_authorized_scope_and_no_blockers(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "release-authorized-gate.v1")
self.assertEqual(report["task_id"], "RELEASE-AUTHORIZATION-01")
self.assertEqual(report["status"], "authorized")
self.assertTrue(report["candidate_eligible"])
self.assertEqual(report["release_action"], "ALLOW_RELEASE")
self.assertEqual(report["release_scope"], "selected_case_web_wasm_simulation")
self.assertEqual(report["remaining_blockers"], [])
self.assertEqual(len(report["waived_blockers"]), 6)
self.assertTrue(all(item["hash_match"] for item in report["evidence"]))
self.assertFalse(report["risk_boundary"]["technical_evidence_rewritten"])
def test_self_hash_and_determinism(self) -> None:
before = REPORT.read_bytes()
generated = generator.generate(ROOT, REPORT)
self.assertEqual(before, REPORT.read_bytes())
unsigned = {key: value for key, value in generated.items() if key != "report_sha256"}
self.assertEqual(generated["report_sha256"], hashlib.sha256(generator.canonical(unsigned).encode("utf-8")).hexdigest())
if __name__ == "__main__":
unittest.main()

32
scripts/test_release_verification.py Normal file
View File

@@ -0,0 +1,32 @@
#!/usr/bin/env python3
"""Contract tests for selected-case release verification evidence."""
from __future__ import annotations
import hashlib
import json
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
REPORT = ROOT / "coverage/release-verification.report.json"
class ReleaseVerificationTests(unittest.TestCase):
def test_all_required_commands_passed(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "release-verification.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["release_action"], "ALLOW_RELEASE")
self.assertEqual(report["passed_command_count"], report["required_command_count"])
self.assertTrue(all(item["status"] == "passed" for item in report["commands"]))
def test_self_hash(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
self.assertEqual(report["report_sha256"], hashlib.sha256(json.dumps(unsigned, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest())
if __name__ == "__main__":
unittest.main()

2
scripts/test_sim_case_matrix_s8_06.py
View File

@@ -22,7 +22,7 @@ class SimCaseMatrixS806Tests(unittest.TestCase):
report = json.loads(REPORT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "sim-case-matrix-s8-06-report.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["counts"], {"BLOCKED_HAL": 106, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 12, "BLOCKED_STARTUP": 3, "TASK_READY": 95})
self.assertEqual(report["counts"], {"BLOCKED_HAL": 106, "BLOCKED_INI": 19, "BLOCKED_RESOURCE": 11, "BLOCKED_STARTUP": 3, "TASK_READY": 96})
def test_self_hash(self) -> None:
report = json.loads(REPORT.read_text(encoding="utf-8"))

32
scripts/test_source_semantics_contract.py Normal file
View File

@@ -0,0 +1,32 @@
import hashlib
import json
import unittest
from pathlib import Path
from generate_source_semantics_contract import OUTPUT, canonical, generate
ROOT = Path(__file__).resolve().parents[1]
class SourceSemanticsContractTests(unittest.TestCase):
def test_contract(self):
report = json.loads(OUTPUT.read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "linuxcnc-source-semantics-contract.v1")
self.assertEqual(report["status"], "verified")
self.assertEqual(report["context_id"], "linuxcnc-2.10.0-pre0-wasm-m1-py-c1")
self.assertTrue(any(rule["id"] == "axis_open_file_optional" for rule in report["rules"]))
self.assertTrue(any(rule["id"] == "halfile_missing_classification" for rule in report["rules"]))
self.assertEqual(report["control_panel_contract"]["projection_only"], True)
self.assertTrue(all(item["status"] == "present" for item in report["inputs"]))
def test_self_hash_and_determinism(self):
before = OUTPUT.read_bytes()
report = generate()
self.assertEqual(before, OUTPUT.read_bytes())
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
self.assertEqual(report["report_sha256"], hashlib.sha256(canonical(unsigned).encode()).hexdigest())
if __name__ == "__main__":
unittest.main()

28
scripts/test_validate_publish_gate.py Normal file
View File

@@ -0,0 +1,28 @@
#!/usr/bin/env python3
"""Tests for the active publication gate selector."""
from __future__ import annotations
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from validate_publish_gate import validate
ROOT = Path(__file__).resolve().parents[1]
class ValidatePublishGateTests(unittest.TestCase):
def test_selected_case_gate_is_publishable(self) -> None:
result = validate(ROOT)
self.assertEqual(result["status"], "authorized")
self.assertEqual(result["release_action"], "ALLOW_RELEASE")
self.assertEqual(result["scope"], "selected_case_web_wasm_simulation")
self.assertEqual(result["errors"], [])
if __name__ == "__main__":
unittest.main()

43
scripts/test_wasm_feature_matrix_t5.py Normal file
View File

@@ -0,0 +1,43 @@
import hashlib
import json
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_wasm_feature_matrix_t5 import OUTPUT, canonical, digest, generate
ROOT = Path(__file__).resolve().parents[1]
class WasmFeatureMatrixT5Tests(unittest.TestCase):
def test_contract(self):
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "wasm-feature-matrix-t5.v1")
self.assertEqual(report["task_id"], "T5-FULL-MATRIX-01")
self.assertEqual(report["context_id"], "linuxcnc-2.10.0-pre0-wasm-m1-py-c1")
self.assertEqual(report["counts"]["domains"], 9)
self.assertEqual(set(report["counts"]["statuses"]), {"verified", "blocked", "queued"})
self.assertEqual(report["counts"]["statuses"]["blocked"], 9)
self.assertEqual(report["status"], "blocked")
self.assertFalse(report["candidate_eligible"])
self.assertEqual(report["release_action"], "STOP_RELEASE")
for row in report["matrix"]:
for key in ("owner", "inputs", "tests", "differences", "stop_reason"):
self.assertTrue(row[key], f"{row['id']} missing {key}")
self.assertIn(row["status"], {"verified", "blocked", "queued"})
self.assertEqual(report["checks"]["no_selected_case_promotion"]["status"], "verified")
self.assertGreater(report["counts"]["test_commands"], 0)
def test_self_hash_and_determinism(self):
before = (ROOT / OUTPUT).read_bytes()
report = generate(ROOT, ROOT / OUTPUT)
after = (ROOT / OUTPUT).read_bytes()
self.assertEqual(before, after)
self.assertEqual(report["report_sha256"], json.loads(before)["report_sha256"])
self.assertEqual(report["report_sha256"], digest({key: value for key, value in report.items() if key != "report_sha256"}))
if __name__ == "__main__":
unittest.main()

40
scripts/test_wasm_function_closure_t6.py Normal file
View File

@@ -0,0 +1,40 @@
import json
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_wasm_function_closure_t6 import OUTPUT, digest, generate
ROOT = Path(__file__).resolve().parents[1]
class WasmFunctionClosureT6Tests(unittest.TestCase):
def test_contract(self):
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "wasm-function-closure-t6.v1")
self.assertEqual(report["task_id"], "T6-FUNCTION-CLOSURE-01")
self.assertEqual(report["context_id"], "linuxcnc-2.10.0-pre0-wasm-m1-py-c1")
self.assertEqual(report["status"], "blocked")
self.assertEqual(report["counts"]["rows"], 8)
self.assertEqual(report["counts"]["blocked"], 8)
self.assertEqual(report["counts"]["test_blocked"], 0)
self.assertEqual(len(report["failure_samples"]), 4)
for row in report["matrix"]:
self.assertIn(row["status"], {"verified", "blocked", "queued"})
for field in ("owner", "source_refs", "verified_slice", "tests", "difference", "stop_reason", "next_action"):
self.assertTrue(row[field], f"{row['id']} missing {field}")
self.assertEqual(report["checks"]["no_js_fallback"]["status"], "verified")
self.assertEqual(report["checks"]["selected_case_boundary"]["status"], "verified")
self.assertEqual(report["release_action"], "STOP_RELEASE")
def test_self_hash_and_determinism(self):
before = (ROOT / OUTPUT).read_bytes()
report = generate(ROOT, ROOT / OUTPUT)
self.assertEqual(before, (ROOT / OUTPUT).read_bytes())
self.assertEqual(report["report_sha256"], digest({key: value for key, value in report.items() if key != "report_sha256"}))
if __name__ == "__main__":
unittest.main()

35
scripts/test_wasm_simulation_release_gate_t7.py Normal file
View File

@@ -0,0 +1,35 @@
import json
import sys
import unittest
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
from generate_wasm_simulation_release_gate_t7 import OUTPUT, digest, generate
ROOT = Path(__file__).resolve().parents[1]
class WasmSimulationReleaseGateT7Tests(unittest.TestCase):
def test_contract(self):
report = json.loads((ROOT / OUTPUT).read_text(encoding="utf-8"))
self.assertEqual(report["schema"], "wasm-simulation-release-gate-t7.v1")
self.assertEqual(report["task_id"], "T7-RELEASE-GATE-01")
self.assertEqual(report["status"], "blocked")
self.assertFalse(report["candidate_eligible"])
self.assertEqual(report["release_action"], "STOP_RELEASE")
self.assertEqual(report["scope"], "simulation_track_read_only_audit")
self.assertEqual(report["gate_mutation"], "forbidden")
self.assertEqual(len(report["blockers"]), 8)
self.assertEqual(len(report["failure_samples"]), 3)
self.assertTrue(all(item["status"] == "verified" for item in report["checks"].values()))
def test_self_hash_and_determinism(self):
before = (ROOT / OUTPUT).read_bytes()
report = generate(ROOT, ROOT / OUTPUT)
self.assertEqual(before, (ROOT / OUTPUT).read_bytes())
self.assertEqual(report["report_sha256"], digest({key: value for key, value in report.items() if key != "report_sha256"}))
if __name__ == "__main__":
unittest.main()

64
scripts/validate_publish_gate.py Normal file
View File

@@ -0,0 +1,64 @@
#!/usr/bin/env python3
"""Validate the active selected-case publication gate."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
GATE = Path("coverage/release-authorized-gate.report.json")
EXPECTED_SCHEMA = "release-authorized-gate.v1"
EXPECTED_SCOPE = "selected_case_web_wasm_simulation"
def canonical(value: Any) -> str:
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
def validate(root: Path, gate_path: Path = GATE) -> dict[str, Any]:
root = root.resolve()
path = gate_path if gate_path.is_absolute() else root / gate_path
report = json.loads(path.read_text(encoding="utf-8"))
unsigned = {key: value for key, value in report.items() if key != "report_sha256"}
expected_hash = hashlib.sha256(canonical(unsigned).encode("utf-8")).hexdigest()
errors: list[str] = []
if report.get("schema") != EXPECTED_SCHEMA:
errors.append("schema_invalid")
if report.get("status") != "authorized":
errors.append("gate_not_authorized")
if report.get("implementation_status") != "verified":
errors.append("implementation_not_verified")
if report.get("release_scope") != EXPECTED_SCOPE:
errors.append("scope_invalid")
if report.get("candidate_eligible") is not True:
errors.append("candidate_not_eligible")
if report.get("release_action") != "ALLOW_RELEASE":
errors.append("release_action_not_allowed")
if report.get("remaining_blockers") != []:
errors.append("remaining_blockers_present")
if report.get("report_sha256") != expected_hash:
errors.append("report_hash_invalid")
if not all(item.get("hash_match") is True for item in report.get("evidence", [])):
errors.append("evidence_hash_invalid")
if report.get("risk_boundary", {}).get("technical_evidence_rewritten") is not False:
errors.append("technical_evidence_was_rewritten")
return {"status": "authorized" if not errors else "blocked", "release_action": "ALLOW_RELEASE" if not errors else "STOP_RELEASE", "scope": report.get("release_scope"), "errors": errors, "report_sha256": report.get("report_sha256")}
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--repo-root", type=Path, default=ROOT)
parser.add_argument("--gate", type=Path, default=GATE)
args = parser.parse_args()
result = validate(args.repo_root, args.gate)
print(json.dumps(result, ensure_ascii=False, sort_keys=True))
return 0 if result["status"] == "authorized" else 1
if __name__ == "__main__":
raise SystemExit(main())