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

Extend simulation runtime coverage and kinematics support

Browse Source
This commit is contained in:
wangdequan
2026-08-21 10:57:10 +08:00
parent 554b72dae8
commit 2ef2d82db3
71 changed files with 24232 additions and 1867 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
web/worker/replay.mjs
View File

@@ -1,8 +1,17 @@
const EVENT_SCHEMA = "event-log.v1";
const SNAPSHOT_SCHEMA = "snapshot.v1";
const REPLAY_SCHEMA = "replay-timeline.v1";
export function canonicalJson(value) {
if (value === null || typeof value !== "object") return JSON.stringify(value);
if (value === null) return "null";
if (typeof value === "number") {
if (!Number.isFinite(value)) throw new Error("canonical_nonfinite");
return JSON.stringify(value);
}
if (typeof value !== "object") {
if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") throw new Error("canonical_unsupported");
return JSON.stringify(value);
}
if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
}
@@ -21,6 +30,15 @@ function requireInteger(value, name) {
if (!Number.isSafeInteger(value) || value < 0) throw new Error(`invalid_${name}`);
}
function requireSequence(value, name) {
requireInteger(value, name);
if (value === 0) throw new Error(`invalid_${name}`);
}
function clone(value) {
return value === undefined ? undefined : structuredClone(value);
}
export class EventLog {
constructor(events = []) {
this.events = [];
@@ -28,27 +46,30 @@ export class EventLog {
}
append(seq, tick, kind, payload = {}, expectedHash = undefined) {
requireInteger(seq, "seq");
requireSequence(seq, "seq");
requireInteger(tick, "tick");
if (seq !== this.cursor + 1) throw new Error("event_sequence_gap");
if (tick < this.tick) throw new Error("event_tick_regression");
if (typeof kind !== "string" || kind.length === 0 || kind.length > 64) throw new Error("event_kind_invalid");
if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("event_payload_invalid");
const payloadHash = fnv1a64(payload);
if (expectedHash !== undefined && expectedHash !== payloadHash) throw new Error("event_payload_hash_mismatch");
const event = { seq, tick, kind, payload, payload_hash: payloadHash };
const event = { seq, tick, kind, payload: clone(payload), payload_hash: payloadHash };
this.events.push(event);
return event;
return clone(event);
}
get cursor() { return this.events.length === 0 ? 0 : this.events[this.events.length - 1].seq; }
get tick() { return this.events.length === 0 ? 0 : this.events[this.events.length - 1].tick; }
export() {
return { schema: EVENT_SCHEMA, cursor: this.cursor, tick: this.tick, events: this.events.map((event) => ({ ...event })) };
return { schema: EVENT_SCHEMA, cursor: this.cursor, tick: this.tick, events: clone(this.events) };
}
static import(value) {
if (!value || value.schema !== EVENT_SCHEMA || !Array.isArray(value.events)) throw new Error("event_log_schema");
requireInteger(value.cursor, "event_cursor");
requireInteger(value.tick, "event_tick");
const log = new EventLog(value.events);
if (log.cursor !== value.cursor || log.tick !== value.tick) throw new Error("event_log_cursor_mismatch");
return log;
@@ -62,9 +83,10 @@ export class SnapshotStore {
}
create(seq, tick, state, baseSnapshotId = null) {
requireInteger(seq, "snapshot_seq");
requireSequence(seq, "snapshot_seq");
requireInteger(tick, "snapshot_tick");
if (baseSnapshotId !== null && !this.snapshots.has(baseSnapshotId)) throw new Error("snapshot_base_missing");
if (state === undefined) throw new Error("snapshot_state_missing");
const stateHash = fnv1a64(state);
const snapshot = {
schema: SNAPSHOT_SCHEMA,
@@ -72,33 +94,43 @@ export class SnapshotStore {
base_snapshot_id: baseSnapshotId,
seq,
tick,
state,
state: clone(state),
state_hash: stateHash,
};
const existingAtSeq = [...this.snapshots.values()].find((candidate) => candidate.seq === seq);
if (existingAtSeq && existingAtSeq.snapshot_id !== snapshot.snapshot_id) throw new Error("snapshot_sequence_duplicate");
if (existingAtSeq) return clone(existingAtSeq);
this.snapshots.set(snapshot.snapshot_id, snapshot);
return snapshot;
return clone(snapshot);
}
importSnapshot(snapshot) {
if (!snapshot || snapshot.schema !== SNAPSHOT_SCHEMA || typeof snapshot.snapshot_id !== "string") throw new Error("snapshot_schema");
requireSequence(snapshot.seq, "snapshot_seq");
requireInteger(snapshot.tick, "snapshot_tick");
if (snapshot.base_snapshot_id !== null && typeof snapshot.base_snapshot_id !== "string") throw new Error("snapshot_base_invalid");
if (snapshot.base_snapshot_id !== null && !this.snapshots.has(snapshot.base_snapshot_id)) throw new Error("snapshot_base_missing");
if (fnv1a64(snapshot.state) !== snapshot.state_hash) throw new Error("snapshot_hash_mismatch");
if (snapshot.snapshot_id !== `snap:${snapshot.seq}:${snapshot.state_hash}`) throw new Error("snapshot_id_mismatch");
this.snapshots.set(snapshot.snapshot_id, { ...snapshot });
return snapshot;
if (this.snapshots.has(snapshot.snapshot_id)) throw new Error("snapshot_duplicate");
if ([...this.snapshots.values()].some((candidate) => candidate.seq === snapshot.seq)) throw new Error("snapshot_sequence_duplicate");
this.snapshots.set(snapshot.snapshot_id, clone(snapshot));
return clone(snapshot);
}
latest() {
return this.snapshots.size === 0 ? null : [...this.snapshots.values()][this.snapshots.size - 1];
if (this.snapshots.size === 0) return null;
return clone([...this.snapshots.values()].sort((left, right) => left.seq - right.seq || left.tick - right.tick || left.snapshot_id.localeCompare(right.snapshot_id)).at(-1));
}
export() {
return { schema: SNAPSHOT_SCHEMA, snapshots: [...this.snapshots.values()].map((snapshot) => ({ ...snapshot })) };
return { schema: SNAPSHOT_SCHEMA, snapshots: clone([...this.snapshots.values()].sort((left, right) => left.seq - right.seq || left.tick - right.tick || left.snapshot_id.localeCompare(right.snapshot_id))) };
}
}
export class ReplayTimeline {
constructor(value = null) {
if (value !== null && (!value || value.schema !== REPLAY_SCHEMA || !value.events || !value.snapshots)) throw new Error("replay_schema");
this.events = value ? EventLog.import(value.events) : new EventLog();
this.snapshots = value ? new SnapshotStore(value.snapshots.snapshots) : new SnapshotStore();
}
@@ -108,18 +140,20 @@ export class ReplayTimeline {
}
checkpoint(seq, tick, state, baseSnapshotId = null) {
if (seq !== this.events.cursor || tick !== this.events.tick) throw new Error("checkpoint_cursor_mismatch");
return this.snapshots.create(seq, tick, state, baseSnapshotId);
}
replay(initialState, apply) {
let state = initialState;
for (const event of this.events.events) state = apply(state, event);
if (typeof apply !== "function") throw new Error("replay_apply_invalid");
let state = clone(initialState);
for (const event of this.events.events) state = apply(state, clone(event));
return { state, state_hash: fnv1a64(state), cursor: this.events.cursor, tick: this.events.tick };
}
export() {
return { events: this.events.export(), snapshots: this.snapshots.export() };
return { schema: REPLAY_SCHEMA, events: this.events.export(), snapshots: this.snapshots.export() };
}
}
export { EVENT_SCHEMA, SNAPSHOT_SCHEMA };
export { EVENT_SCHEMA, SNAPSHOT_SCHEMA, REPLAY_SCHEMA };

145
web/worker/sim-session.mjs
View File

@@ -1,9 +1,18 @@
import { ReplayTimeline, fnv1a64 } from "./replay.mjs";
import { capabilities, validateLimit } from "./capabilities.mjs";
import { mapCoreError } from "./error-map.mjs";
import { createCheckpoint, recoverSimulation } from "../workspace/recovery.mjs";
const PROTOCOL_SCHEMA = 1;
const CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m0-c1";
const CONTEXT_ID = "linuxcnc-2.10.0-pre0-wasm-m1-py-c1";
const OPERATION_KINDS = new Set([
"LOAD_WORKSPACE", "SIM_STEP", "DESTROY", "CHECKPOINT", "RECOVER", "ABORT",
"COMMAND", "START", "STOP", "RESET", "PROGRAM_LOAD", "PROGRAM_RUN",
"PROGRAM_PAUSE", "PROGRAM_RESUME", "PROGRAM_ABORT", "JOG_START", "JOG_STOP",
"HOME", "SET_MODE", "SET_OVERRIDE", "SPINDLE_COMMAND", "TOOL_PREPARE",
"TOOL_CHANGE", "PROBE_CONFIG", "HAL_COMMAND", "HAL_SET",
]);
function text(value) {
return typeof value === "string" && value.length > 0 ? value : null;
@@ -42,6 +51,7 @@ export class SimSession {
this.tick = 0;
this.created = false;
this.timeline = new ReplayTimeline();
this.operations = new Map();
call(core, "sim_protocol_reset");
if (typeof core.ccall === "function") core.ccall("sim_event_reset", null, [], []);
}
@@ -75,6 +85,60 @@ export class SimSession {
return this.envelope("ERROR", input, mapped);
}
operationState(input) {
if (!text(input.operation_id) || !OPERATION_KINDS.has(input.kind)) return null;
return this.operations.get(input.operation_id) ?? null;
}
stateForCheckpoint() {
return {
context_id: this.contextId,
session_id: this.sessionId,
tick: this.tick,
created: this.created,
protocol_seq: this.timeline.events.cursor,
};
}
createCheckpoint() {
const latest = this.timeline.snapshots.latest();
if (!latest || latest.seq !== this.timeline.events.cursor || latest.tick !== this.timeline.events.tick) {
this.timeline.checkpoint(
this.timeline.events.cursor,
this.timeline.events.tick,
this.stateForCheckpoint(),
latest?.snapshot_id ?? null,
);
}
return createCheckpoint({
contextId: this.contextId,
timeline: this.timeline,
state: this.stateForCheckpoint(),
operations: [...this.operations.values()],
});
}
restoreCheckpoint(checkpoint, events = null, reconcile = undefined) {
const result = recoverSimulation({
checkpoint,
contextId: this.contextId,
events,
reconcile,
apply: (state, event) => ({ ...state, tick: event.tick }),
});
if (result.status === "recovered" || result.status === "aborted") {
this.tick = result.simulation_tick;
this.timeline = new ReplayTimeline(checkpoint.timeline);
if (events?.schema === "replay-timeline.v1") {
for (const event of events.events.events.slice(this.timeline.events.cursor)) this.timeline.appendEvent(event.seq, event.tick, event.kind, event.payload, event.payload_hash);
} else if (Array.isArray(events)) {
for (const event of events) this.timeline.appendEvent(event.seq, event.tick, event.kind, event.payload, event.payload_hash);
}
this.operations = new Map(result.operations.map((operation) => [operation.operation_id, operation]));
}
return result;
}
validateEnvelope(input) {
if (!input || typeof input !== "object") return ["protocol_argument", "invalid_envelope"];
if (input.schema_version !== PROTOCOL_SCHEMA) return ["protocol_schema", "unsupported_schema"];
@@ -90,53 +154,106 @@ export class SimSession {
if (invalid) return this.error(input ?? {}, invalid[0], invalid[1]);
const result = call(this.core, "sim_protocol_accept", input.schema_version, input.seq, input.kind, input.operation_id ?? "", input.simulation_tick ?? this.tick);
if (result !== 0) return this.coreError(input, result, "sim_protocol_accept");
const existingOperation = this.operationState(input);
if (existingOperation?.response) {
if (existingOperation.kind !== input.kind) return this.error(input, "recovery_operation_conflict", "operation_id_conflict");
try {
const replayTick = Number.isSafeInteger(input.simulation_tick) && input.simulation_tick >= this.tick ? input.simulation_tick : this.tick;
this.timeline.appendEvent(input.seq, replayTick, "OPERATION_REPLAY", { operation_id: input.operation_id, original_seq: existingOperation.seq });
const replayEventResult = appendCoreEvent(this.core, input.seq, replayTick, "OPERATION_REPLAY", { operation_id: input.operation_id, original_seq: existingOperation.seq });
if (replayEventResult !== 0) return this.error(input, "event_log", "core_event_append_failed");
this.tick = replayTick;
return { ...existingOperation.response, replayed: true, seq: input.seq };
} catch (error) {
return this.error(input, "event_log", String(error?.message ?? error));
}
}
if (text(input.operation_id) && OPERATION_KINDS.has(input.kind)) {
this.operations.set(input.operation_id, { operation_id: input.operation_id, status: "executing", seq: input.seq, kind: input.kind, result_hash: null });
}
if (Number.isSafeInteger(input.simulation_tick) && input.simulation_tick >= this.tick) this.tick = input.simulation_tick;
const eventTick = input.kind === "SIM_STEP" && Number.isSafeInteger(input.payload?.cycles)
? this.tick + input.payload.cycles : this.tick;
try {
this.timeline.appendEvent(input.seq, eventTick, input.kind, input.payload ?? {});
} catch (error) {
if (text(input.operation_id)) this.operations.delete(input.operation_id);
return this.error(input, "event_log", String(error?.message ?? error));
}
const coreEventResult = appendCoreEvent(this.core, input.seq, eventTick, input.kind, input.payload ?? {});
if (coreEventResult !== 0) return this.error(input, "event_log", "core_event_append_failed");
if (coreEventResult !== 0) {
if (text(input.operation_id)) this.operations.delete(input.operation_id);
return this.error(input, "event_log", "core_event_append_failed");
}
const finish = (response, status = "verified") => {
if (text(input.operation_id) && OPERATION_KINDS.has(input.kind)) {
const operation = this.operations.get(input.operation_id);
if (operation) {
operation.status = status;
operation.result_hash = fnv1a64(response.payload ?? {});
operation.response = response;
}
}
return response;
};
switch (input.kind) {
case "HELLO":
return this.envelope("CAPABILITIES", input, capabilities(this.contextId));
return finish(this.envelope("CAPABILITIES", input, capabilities(this.contextId)), "verified");
case "SESSION_ATTACH":
if (!this.created) {
const createResult = call(this.core, "sim_create", 0, 0);
if (createResult !== 0) return this.coreError(input, createResult, "sim_create");
if (createResult !== 0) return finish(this.coreError(input, createResult, "sim_create"), "failed");
this.created = true;
}
return this.envelope("SESSION_READY", input, { state_hash: fnv1a64({ tick: this.tick }), subscriptions: [] });
return finish(this.envelope("SESSION_READY", input, { state_hash: fnv1a64({ tick: this.tick }), subscriptions: [] }), "verified");
case "LOAD_WORKSPACE": {
const rootPath = input.payload?.root_path;
if (!text(rootPath) || !rootPath.startsWith("/") || rootPath.includes("..")) return this.error(input, "workspace_path", "invalid_workspace_path");
if (!text(rootPath) || !rootPath.startsWith("/") || rootPath.includes("..")) return finish(this.error(input, "workspace_path", "invalid_workspace_path"), "failed");
const loadResult = call(this.core, "sim_load_workspace", rootPath);
return loadResult === 0 ? this.envelope("COMMAND_RESULT", input, { status: "verified", command: input.kind, state_hash: fnv1a64({ tick: this.tick }) }) : this.coreError(input, loadResult, "sim_load_workspace");
return loadResult === 0 ? finish(this.envelope("COMMAND_RESULT", input, { status: "verified", command: input.kind, state_hash: fnv1a64({ tick: this.tick }) })) : finish(this.coreError(input, loadResult, "sim_load_workspace"), "failed");
}
case "SIM_STEP": {
const cycles = input.payload?.cycles;
const limit = validateLimit("max_tick_step", cycles);
if (limit.status !== "accepted") return this.envelope("ERROR", input, { ...limit, operation_id: input.operation_id ?? null, simulation_tick: this.tick, retryable: false });
if (limit.status !== "accepted") return finish(this.envelope("ERROR", input, { ...limit, operation_id: input.operation_id ?? null, simulation_tick: this.tick, retryable: false }), "failed");
const stepResult = call(this.core, "sim_step", cycles);
if (stepResult !== 0) return this.coreError(input, stepResult, "sim_step");
if (stepResult !== 0) return finish(this.coreError(input, stepResult, "sim_step"), "failed");
this.tick += cycles;
const protocolTick = call(this.core, "sim_protocol_set_tick", this.tick);
if (protocolTick !== 0) return this.error(input, "protocol_tick", "tick_update_failed");
if (protocolTick !== 0) return finish(this.error(input, "protocol_tick", "tick_update_failed"), "failed");
const snapshot = this.timeline.checkpoint(input.seq, this.tick, { tick: this.tick, cycles }, this.timeline.snapshots.latest()?.snapshot_id ?? null);
return this.envelope("COMMAND_RESULT", input, { status: "verified", cycles, state_hash: snapshot.state_hash, snapshot });
return finish(this.envelope("COMMAND_RESULT", input, { status: "verified", cycles, state_hash: snapshot.state_hash, snapshot }));
}
case "SNAPSHOT_REQUEST":
return this.envelope("STATE_SNAPSHOT", input, { snapshot_schema: 1, tick: this.tick, state_hash: fnv1a64({ tick: this.tick }), snapshot: this.timeline.snapshots.latest() });
return finish(this.envelope("STATE_SNAPSHOT", input, { snapshot_schema: 1, tick: this.tick, state_hash: fnv1a64({ tick: this.tick }), snapshot: this.timeline.snapshots.latest() }));
case "CHECKPOINT": {
try {
const operation = text(input.operation_id) ? this.operations.get(input.operation_id) : null;
if (operation) operation.status = "verified";
const checkpoint = this.createCheckpoint();
return finish(this.envelope("CHECKPOINT_READY", input, { status: "verified", checkpoint, state_hash: checkpoint.checkpoint_hash }));
} catch (error) {
return finish(this.error(input, "recovery_checkpoint", String(error?.message ?? error)), "failed");
}
}
case "RECOVER": {
const result = this.restoreCheckpoint(input.payload?.checkpoint, input.payload?.events, input.payload?.reconcile);
return finish(this.envelope("RECOVERY_STATUS", input, result), result.status === "blocked" ? "failed" : "verified");
}
case "ABORT": {
const target = input.payload?.operation_id;
const operation = text(target) ? this.operations.get(target) : null;
if (operation && operation.status !== "verified") operation.status = "aborted";
return finish(this.envelope("COMMAND_RESULT", input, { status: operation ? "aborted" : "verified", operation_id: target ?? null }));
}
case "DESTROY":
call(this.core, "sim_destroy");
this.created = false;
return this.envelope("COMMAND_RESULT", input, { status: "verified", destroyed: true, replay: this.timeline.export() });
return finish(this.envelope("COMMAND_RESULT", input, { status: "verified", destroyed: true, replay: this.timeline.export() }));
default:
return this.envelope("COMMAND_RESULT", input, { status: "verified", command: input.kind });
return finish(this.envelope("COMMAND_RESULT", input, { status: "verified", command: input.kind }));
}
}
}

9
web/worker/test_replay.mjs
View File

@@ -1,5 +1,5 @@
import assert from "node:assert/strict";
import { EventLog, ReplayTimeline, SnapshotStore, fnv1a64 } from "./replay.mjs";
import { EventLog, ReplayTimeline, SnapshotStore, fnv1a64, REPLAY_SCHEMA } from "./replay.mjs";
function buildTimeline() {
const timeline = new ReplayTimeline();
@@ -34,6 +34,13 @@ assert.throws(() => {
}, /snapshot_base_missing/);
const exported = first.export();
assert.equal(exported.schema, REPLAY_SCHEMA);
exported.snapshots.snapshots[0].state_hash = "fnv1a64:0000000000000000";
assert.throws(() => new ReplayTimeline(exported), /snapshot_hash_mismatch/);
assert.throws(() => new EventLog([{ seq: 1, tick: 0, kind: "DUP", payload: {}, payload_hash: fnv1a64({}) }, { seq: 1, tick: 1, kind: "DUP", payload: {}, payload_hash: fnv1a64({}) }]), /event_sequence_gap/);
assert.throws(() => first.checkpoint(3, 8, { tick: 8 }), /checkpoint_cursor_mismatch/);
assert.throws(() => first.checkpoint(3, 9, { tick: 9, position: 99 }), /snapshot_sequence_duplicate/);
const duplicateSnapshot = first.export();
duplicateSnapshot.snapshots.snapshots.push({ ...duplicateSnapshot.snapshots.snapshots[1] });
assert.throws(() => new ReplayTimeline(duplicateSnapshot), /snapshot_duplicate/);
console.log("replay=passed cursor=" + replay.cursor + " tick=" + replay.tick);

11
web/worker/test_sim_session.mjs
View File

@@ -33,4 +33,15 @@ assert.equal(response.payload.tick, 7);
response = session.accept({ ...base, kind: "SIM_STEP", seq: 7, operation_id: "op-7", payload: { cycles: 1 } });
assert.equal(response.kind, "ERROR");
assert.equal(response.payload.code, "protocol_sequence");
response = session.accept({ ...base, kind: "CHECKPOINT", seq: 6, operation_id: "op-checkpoint", payload: {} });
assert.equal(response.kind, "CHECKPOINT_READY");
const checkpoint = response.payload.checkpoint;
response = session.accept({ ...base, kind: "SIM_STEP", seq: 7, operation_id: "op-7", payload: { cycles: 1 } });
assert.equal(response.kind, "COMMAND_RESULT");
const replayed = session.accept({ ...base, kind: "SIM_STEP", seq: 8, operation_id: "op-7", payload: { cycles: 99 } });
assert.equal(replayed.replayed, true);
assert.equal(replayed.payload.cycles, 1);
const recovered = session.restoreCheckpoint(checkpoint, null, (operation) => operation);
assert.equal(recovered.status, "recovered");
assert.equal(recovered.simulation_tick, 7);
console.log("sim_session=passed calls=" + calls.length);