simple-circuit-engine 0.0.9 → 0.0.11

package/dist/{CircuitRunner-FXM_s5ll.js → CircuitRunner-BQQlhwjD.js}

@@ -1,4 +1,4 @@
-class w {
+class m {
   /**
    * Create a new 3D position.
    *
@@ -6,8 +6,8 @@ class w {
    * @param y - Y coordinate
    * @param z - Z coordinate
    */
-  constructor(t, e, r) {
-    this.x = t, this.y = e, this.z = r;
+  constructor(t, e, i) {
+    this.x = t, this.y = e, this.z = i;
   }
   /**
    * Check if this position equals another position.
@@ -57,7 +57,7 @@ class w {
    * ```
    */
   static fromJSON(t) {
-    return new w(t.x, t.y, t.z);
+    return new m(t.x, t.y, t.z);
   }
   /**
    * String representation for debugging.
@@ -68,7 +68,7 @@ class w {
     return `Position(${this.x}, ${this.y}, ${this.z})`;
   }
 }
-class k {
+class M {
   /**
    * Create new camera options.
    *
@@ -78,8 +78,8 @@ class k {
    * @param near - Near clipping plane distance (default: 0.1)
    * @param far - Far clipping plane distance (default: 1000)
    */
-  constructor(t = new w(0, 15, 15), e = new w(0, 0, 0), r = 75, i = 0.1, o = 1e3) {
-    this.position = t, this.lookAtPosition = e, this.fov = r, this.near = i, this.far = o;
+  constructor(t = new m(0, 15, 15), e = new m(0, 0, 0), i = 75, n = 0.1, r = 1e3) {
+    this.position = t, this.lookAtPosition = e, this.fov = i, this.near = n, this.far = r;
   }
   /**
    * Serialize camera options to JSON.
@@ -129,9 +129,9 @@ class k {
    * ```
    */
   static fromJSON(t) {
-    return new k(
-      w.fromJSON(t.position),
-      w.fromJSON(t.lookAtPosition),
+    return new M(
+      m.fromJSON(t.position),
+      m.fromJSON(t.lookAtPosition),
       t.fov,
       t.near,
       t.far
@@ -146,137 +146,7 @@ class k {
     return `CameraOptions(position: ${this.position.toString()}, lookAt: ${this.lookAtPosition.toString()}, fov: ${this.fov}, near: ${this.near}, far: ${this.far})`;
   }
 }
-var S = /* @__PURE__ */ ((n) => (n.Voltage = "Voltage", n.Current = "Current", n))(S || {}), T = /* @__PURE__ */ ((n) => (n.Battery = "battery", n.Switch = "switch", n.Lightbulb = "lightbulb", n.Relay = "relay", n.Transistor = "transistor", n.SmallLED = "smallLED", n.RectangleLED = "rectangleLED", n.Cube = "cube", n.Label = "label", n))(T || {});
-const E = {
-  switch: {
-    id: "switch",
-    name: "Switch",
-    pins: /* @__PURE__ */ new Map([
-      ["input", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["initialState", "open"],
-      ["size", "1"]
-    ])
-  },
-  battery: {
-    id: "battery",
-    name: "Battery",
-    pins: /* @__PURE__ */ new Map([
-      ["cathode", S.Voltage],
-      ["anode", S.Current]
-    ]),
-    config: /* @__PURE__ */ new Map([])
-  },
-  lightbulb: {
-    id: "lightbulb",
-    name: "Lightbulb",
-    pins: /* @__PURE__ */ new Map([
-      ["pin1", void 0],
-      ["pin2", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([["size", "1"]])
-  },
-  relay: {
-    id: "relay",
-    name: "Relay",
-    pins: /* @__PURE__ */ new Map([
-      ["cmd_in", void 0],
-      ["cmd_out", void 0],
-      ["power_in", void 0],
-      ["power_out", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  transistor: {
-    id: "transistor",
-    name: "Transistor",
-    pins: /* @__PURE__ */ new Map([
-      ["collector", void 0],
-      ["base", void 0],
-      ["emitter", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  smallLED: {
-    id: "smallLED",
-    name: "SmallLED",
-    pins: /* @__PURE__ */ new Map([
-      ["cathode", void 0],
-      ["anode", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["mode", "symmetric"],
-      ["idleColor", "white"],
-      ["activeColor", "#ffff00"],
-      ["size", "1"],
-      ["ywRatio", "1"]
-    ])
-  },
-  rectangleLED: {
-    id: "rectangleLED",
-    name: "RectangleLED",
-    pins: /* @__PURE__ */ new Map([
-      ["cathode", void 0],
-      ["anode", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["mode", "symmetric"],
-      ["idleColor", "white"],
-      ["activeColor", "#ffff00"],
-      ["size", "1"],
-      ["hwRatio", "1"],
-      ["ywRatio", "1"]
-    ])
-  },
-  cube: {
-    id: "cube",
-    name: "Cube",
-    pins: /* @__PURE__ */ new Map([]),
-    config: /* @__PURE__ */ new Map([["color", "red"]])
-  },
-  label: {
-    id: "label",
-    name: "Label",
-    pins: /* @__PURE__ */ new Map([]),
-    config: /* @__PURE__ */ new Map([
-      ["text", "Label"],
-      ["size", "1"]
-    ])
-  }
-};
-function z() {
-  return Object.values(T);
-}
-function N(n) {
-  return E[n];
-}
-var M = /* @__PURE__ */ ((n) => (n.Pin = "Pin", n.BranchingPoint = "BranchingPoint", n))(M || {});
-function I() {
-  if (typeof crypto < "u" && crypto.randomUUID)
-    return crypto.randomUUID();
-  const n = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
-  for (const c of t) {
-    let l = "";
-    for (let s = 0; s < c; s++) {
-      const h = Math.floor(Math.random() * 16);
-      l += n[h];
-    }
-    e.push(l);
-  }
-  const i = e.join("-").split("");
-  i[14] = "4";
-  const a = parseInt(i[19] ?? "0", 16) & 3 | 8;
-  return i[19] = n[a] ?? "0", i.join("");
-}
-class v {
+class T {
   /**
    * Create a new position on the discrete grid.
    *
@@ -337,7 +207,7 @@ class v {
    * ```
    */
   static fromJSON(t) {
-    return new v(t.x, t.y);
+    return new T(t.x, t.y);
   }
   /**
    * String representation for debugging.
@@ -348,44 +218,44 @@ class v {
     return `Position(${this.x}, ${this.y})`;
   }
 }
-function W(n, t, e = 1 / 0) {
-  if (n.length === 0)
+function R(o, t, e = 1 / 0) {
+  if (o.length === 0)
     return 0;
-  if (n.length === 1)
+  if (o.length === 1)
     return 1;
-  let r = 1;
-  for (let i = 0; i < n.length - 1; i++) {
-    const o = n[i], a = n[i + 1], c = O(t, o, a);
-    c < e && (e = c, r = i + 1);
+  let i = 1;
+  for (let n = 0; n < o.length - 1; n++) {
+    const r = o[n], a = o[n + 1], c = N(t, r, a);
+    c < e && (e = c, i = n + 1);
   }
-  return r;
+  return i;
 }
-function O(n, t, e) {
-  const r = e.x - t.x, i = e.y - t.y, o = r * r + i * i;
-  if (o === 0)
-    return Math.sqrt((n.x - t.x) ** 2 + (n.y - t.y) ** 2);
+function N(o, t, e) {
+  const i = e.x - t.x, n = e.y - t.y, r = i * i + n * n;
+  if (r === 0)
+    return Math.sqrt((o.x - t.x) ** 2 + (o.y - t.y) ** 2);
   const a = Math.max(
     0,
     Math.min(
       1,
-      ((n.x - t.x) * r + (n.y - t.y) * i) / o
+      ((o.x - t.x) * i + (o.y - t.y) * n) / r
     )
-  ), c = t.x + a * r, l = t.y + a * i;
-  return Math.sqrt((n.x - c) ** 2 + (n.y - l) ** 2);
+  ), c = t.x + a * i, h = t.y + a * n;
+  return Math.sqrt((o.x - c) ** 2 + (o.y - h) ** 2);
 }
-function L(n, t = 5) {
-  if (n.length <= 2)
-    return [...n];
-  const e = [n[0]];
-  for (let r = 1; r < n.length - 1; r++) {
-    const i = e[e.length - 1], o = n[r], a = n[r + 1];
-    D(i, o, a, t) || e.push(o);
-  }
-  return e.push(n[n.length - 1]), e;
+function z(o, t = 5) {
+  if (o.length <= 2)
+    return [...o];
+  const e = [o[0]];
+  for (let i = 1; i < o.length - 1; i++) {
+    const n = e[e.length - 1], r = o[i], a = o[i + 1];
+    A(n, r, a, t) || e.push(r);
+  }
+  return e.push(o[o.length - 1]), e;
 }
-function D(n, t, e, r = 5) {
-  const i = (t.x - n.x) * (e.y - n.y) - (t.y - n.y) * (e.x - n.x);
-  return Math.abs(i) <= r;
+function A(o, t, e, i = 5) {
+  const n = (t.x - o.x) * (e.y - o.y) - (t.y - o.y) * (e.x - o.x);
+  return Math.abs(n) <= i;
 }
 class C {
   /**
@@ -457,7 +327,629 @@ class C {
     return `Rotation(${this.angle}°)`;
   }
 }
-class A {
+function O() {
+  if (typeof crypto < "u" && crypto.randomUUID)
+    return crypto.randomUUID();
+  const o = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
+  for (const c of t) {
+    let h = "";
+    for (let s = 0; s < c; s++) {
+      const u = Math.floor(Math.random() * 16);
+      h += o[u];
+    }
+    e.push(h);
+  }
+  const n = e.join("-").split("");
+  n[14] = "4";
+  const a = parseInt(n[19] ?? "0", 16) & 3 | 8;
+  return n[19] = o[a] ?? "0", n.join("");
+}
+const G = "0.0.11";
+var v = /* @__PURE__ */ ((o) => (o.Voltage = "Voltage", o.Current = "Current", o))(v || {}), S = /* @__PURE__ */ ((o) => (o.Pin = "Pin", o.BranchingPoint = "BranchingPoint", o))(S || {});
+const W = ["CMOS1", "TTL1", "Sandbox"], U = "CMOS1";
+var L = /* @__PURE__ */ ((o) => (o.Cube = "cube", o.Label = "label", o.Battery = "battery", o.Switch = "switch", o.DoubleThrowSwitch = "doubleThrowSwitch", o.Lightbulb = "lightbulb", o.Relay = "relay", o.SmallLED = "smallLED", o.RectangleLED = "rectangleLED", o.Inverter = "inverter", o.NandGate = "nandGate", o.Nand4Gate = "nand4Gate", o.Nand8Gate = "nand8Gate", o.NorGate = "norGate", o.Nor4Gate = "nor4Gate", o.Nor8Gate = "nor8Gate", o.XorGate = "xorGate", o.Xor4Gate = "xor4Gate", o.Xor8Gate = "xor8Gate", o))(L || {});
+const I = {
+  switch: {
+    id: "switch",
+    name: "Switch",
+    pins: /* @__PURE__ */ new Map([
+      ["input", { subtype: "free", sourceType: void 0 }],
+      ["output", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "open"],
+      ["size", "1"]
+    ])
+  },
+  doubleThrowSwitch: {
+    id: "doubleThrowSwitch",
+    // SPDT (Single-Pole Double-Throw) Switch
+    name: "DoubleThrowSwitch",
+    pins: /* @__PURE__ */ new Map([
+      ["input1", { subtype: "free", sourceType: void 0 }],
+      ["input2", { subtype: "free", sourceType: void 0 }],
+      ["output", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "input1"],
+      ["size", "1"]
+    ])
+  },
+  battery: {
+    id: "battery",
+    name: "Battery",
+    pins: /* @__PURE__ */ new Map([
+      ["cathode", {
+        subtype: "mainVcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["anode", {
+        subtype: "mainGnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([])
+  },
+  lightbulb: {
+    id: "lightbulb",
+    name: "Lightbulb",
+    pins: /* @__PURE__ */ new Map([
+      ["pin1", { subtype: "free", sourceType: void 0 }],
+      ["pin2", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([["size", "1"]])
+  },
+  relay: {
+    id: "relay",
+    name: "Relay",
+    pins: /* @__PURE__ */ new Map([
+      ["cmd_in", { subtype: "free", sourceType: void 0 }],
+      ["cmd_out", { subtype: "free", sourceType: void 0 }],
+      ["power_in", { subtype: "free", sourceType: void 0 }],
+      ["power_out", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["activationLogic", "positive"],
+      ["initializationOrder", ""]
+    ])
+  },
+  smallLED: {
+    id: "smallLED",
+    name: "SmallLED",
+    pins: /* @__PURE__ */ new Map([
+      ["pin1", { subtype: "free", sourceType: void 0 }],
+      ["pin2", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  rectangleLED: {
+    id: "rectangleLED",
+    name: "RectangleLED",
+    pins: /* @__PURE__ */ new Map([
+      ["pin1", { subtype: "free", sourceType: void 0 }],
+      ["pin2", { subtype: "free", sourceType: void 0 }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["hwRatio", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  cube: {
+    id: "cube",
+    name: "Cube",
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([["color", "red"]])
+  },
+  label: {
+    id: "label",
+    name: "Label",
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([
+      ["text", "Label"],
+      ["size", "1"]
+    ])
+  },
+  inverter: {
+    id: "inverter",
+    name: "Inverter",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  nandGate: {
+    id: "nandGate",
+    name: "NAND Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  nand4Gate: {
+    id: "nand4Gate",
+    name: "NAND4 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  nand8Gate: {
+    id: "nand8Gate",
+    name: "NAND8 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["input5", { subtype: "logicInput", sourceType: void 0 }],
+      ["input6", { subtype: "logicInput", sourceType: void 0 }],
+      ["input7", { subtype: "logicInput", sourceType: void 0 }],
+      ["input8", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  },
+  norGate: {
+    id: "norGate",
+    name: "NOR Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "1"],
+      ["initializationOrder", ""]
+    ])
+  },
+  nor4Gate: {
+    id: "nor4Gate",
+    name: "NOR4 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  nor8Gate: {
+    id: "nor8Gate",
+    name: "NOR8 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["input5", { subtype: "logicInput", sourceType: void 0 }],
+      ["input6", { subtype: "logicInput", sourceType: void 0 }],
+      ["input7", { subtype: "logicInput", sourceType: void 0 }],
+      ["input8", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "negative"],
+      ["transitionSpan", "3"],
+      ["initializationOrder", ""]
+    ])
+  },
+  xorGate: {
+    id: "xorGate",
+    name: "XOR Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "2"],
+      ["initializationOrder", ""]
+    ])
+  },
+  xor4Gate: {
+    id: "xor4Gate",
+    name: "XOR4 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "4"],
+      ["initializationOrder", ""]
+    ])
+  },
+  xor8Gate: {
+    id: "xor8Gate",
+    name: "XOR8 Gate",
+    pins: /* @__PURE__ */ new Map([
+      ["vcc", {
+        subtype: "vcc",
+        sourceType: "Voltage"
+        /* Voltage */
+      }],
+      ["input1", { subtype: "logicInput", sourceType: void 0 }],
+      ["input2", { subtype: "logicInput", sourceType: void 0 }],
+      ["input3", { subtype: "logicInput", sourceType: void 0 }],
+      ["input4", { subtype: "logicInput", sourceType: void 0 }],
+      ["input5", { subtype: "logicInput", sourceType: void 0 }],
+      ["input6", { subtype: "logicInput", sourceType: void 0 }],
+      ["input7", { subtype: "logicInput", sourceType: void 0 }],
+      ["input8", { subtype: "logicInput", sourceType: void 0 }],
+      ["output", { subtype: "logicOutput", sourceType: void 0 }],
+      ["gnd", {
+        subtype: "gnd",
+        sourceType: "Current"
+        /* Current */
+      }]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["defaultLogicFamily", "CMOS1"],
+      ["activationLogic", "positive"],
+      ["transitionSpan", "6"],
+      ["initializationOrder", ""]
+    ])
+  }
+};
+class k {
+  /**
+   * Unique identifier for this ENode.
+   * @readonly
+   */
+  id;
+  /**
+   * Type of electrical node (Pin or BranchingPoint).
+   * @readonly
+   */
+  type;
+  /**
+   * Parent component UUID (only for pin nodes).
+   * Undefined for branching point nodes.
+   * @readonly
+   */
+  component;
+  /**
+   * Pin label within component (only for pin nodes).
+   * Undefined for branching point nodes.
+   * @readonly
+   */
+  pinLabel;
+  /**
+   * Grid position (only for branching point nodes).
+   * Undefined for pin nodes (position derived from component).
+   * @readonly
+   */
+  position;
+  /**
+   * Set of wire UUIDs connected to this node.
+   * Mutable to allow wire connections/disconnections.
+   */
+  wires;
+  /**
+   * Is the ENode a source of voltage or current?
+   */
+  source;
+  /**
+   * Pin role classification: free, mainVcc, vcc, mainGnd, gnd, logicInput, logicOutput.
+   * @readonly
+   */
+  subtype;
+  /**
+   * Create a new electrical node.
+   *
+   * **Note**: Typically ENodes are created automatically by Circuit.
+   * This constructor is used internally.
+   *
+   * @param type - Node type (Pin or BranchingPoint)
+   * @param component - Parent component UUID (pin nodes only)
+   * @param pinLabel - Pin label (pin nodes only)
+   * @param position - Grid position (branching points only)
+   * @param source - Source type (Voltage/Current) or undefined
+   *
+   * @param subtype
+   * @example
+   * ```typescript
+   * // Pin node (internal to Circuit)
+   * const pinNode = new ENode(
+   *   ENodeType.Pin,
+   *   componentId,
+   *   '0',  // first pin
+   *   undefined,
+   *   undefined
+   * );
+   *
+   * // Branching point node
+   * const branchNode = new ENode(
+   *   ENodeType.BranchingPoint,
+   *   undefined,
+   *   undefined,
+   *   new Position(15, 25),
+   *   undefined
+   * );
+   * ```
+   */
+  constructor(t, e, i, n, r = void 0, a = "free") {
+    this.id = O(), this.type = t, this.component = e, this.pinLabel = i, this.position = n, this.wires = /* @__PURE__ */ new Set(), this.source = r, this.subtype = a;
+  }
+  /**
+   * Get the position of this electrical node.
+   *
+   * **Pin nodes**: Derives position from parent component.
+   * **Branching nodes**: Returns stored position directly.
+   *
+   * @param circuit - Circuit instance (needed to look up component for pin nodes)
+   * @returns Position on the grid
+   *
+   * @example
+   * ```typescript
+   * const circuit = new Circuit();
+   * const component = circuit.addComponent(
+   *   new Position(10, 20),
+   *   new Rotation(0),
+   *   1
+   * );
+   *
+   * const pinNode = circuit.getENode(component.pins[0]);
+   * const position = pinNode.getPosition(circuit);
+   * console.log(position.x); // 10 (derived from component)
+   * ```
+   */
+  getPosition(t) {
+    if (this.type === S.Pin) {
+      if (!this.component)
+        throw new Error("Pin node missing component reference");
+      const e = t.getComponent(this.component);
+      if (!e)
+        throw new Error(`Component ${this.component} not found for pin node ${this.id}`);
+      return e.position;
+    }
+    if (!this.position)
+      throw new Error("Branching point node missing position");
+    return this.position;
+  }
+  /**
+   * Update the enode (branching point only)'s position.
+   *
+   * @param newPosition - The new position for the enode
+   *
+   * @example
+   * ```typescript
+   * const component = circuit.getComponent(componentId);
+   * component.setPosition(new Position(15, 25));
+   * ```
+   */
+  setPosition(t) {
+    Object.defineProperty(this, "position", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  /**
+   * Update the enode's source type.
+   * @param sourceType
+   */
+  setSourceType(t) {
+    Object.defineProperty(this, "source", {
+      value: t,
+      writable: !0,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  /**
+   * Serialize ENode to JSON.
+   *
+   * @returns Plain object representation
+   *
+   * @example
+   * ```typescript
+   * const json = enode.toJSON();
+   * console.log(json);
+   * // Pin node:
+   * // {
+   * //   id: "uuid",
+   * //   type: "Pin",
+   * //   component: "component-uuid",
+   * //   pinLabel: "0"
+   * // }
+   *
+   * // Branching node:
+   * // {
+   * //   id: "uuid",
+   * //   type: "BranchingPoint",
+   * //   position: { x: 15, y: 25 }
+   * // }
+   * ```
+   */
+  toJSON() {
+    const t = {
+      id: this.id,
+      type: this.type,
+      source: this.source || null,
+      subtype: this.subtype
+    };
+    return this.type === S.Pin ? (t.component = this.component || null, t.pinLabel = this.pinLabel || null) : t.position = this.position?.toJSON() || null, t;
+  }
+  /**
+   * Deserialize ENode from JSON.
+   *
+   * @param json - ENode data
+   * @returns ENode instance
+   *
+   * @example
+   * ```typescript
+   * const json = {
+   *   id: "uuid",
+   *   type: "Pin",
+   *   component: "component-uuid",
+   *   pinLabel: "0"
+   * };
+   *
+   * const enode = ENode.fromJSON(json);
+   * ```
+   */
+  static fromJSON(t) {
+    const e = t.position ? T.fromJSON(t.position) : void 0, i = new k(
+      t.type,
+      t.component || void 0,
+      t.pinLabel || void 0,
+      e,
+      t.source || void 0,
+      t.subtype ?? "free"
+    );
+    return Object.defineProperty(i, "id", {
+      value: t.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}
+class E {
   /**
    * Unique identifier for this component.
    * @readonly
@@ -488,10 +980,14 @@ class A {
    * Configuration parameters for this component instance.
    *
    * This map holds key-value pairs representing configurable settings
-   * The available configuration keys depend on the component type see ComponentTypeMetadata for details.
+   * The available configuration keys depend on the component type see IComponentTypeMetadata for details.
    *
    */
   config;
+  /**
+   * allow to flag a component as non editable (feature to implement)
+   */
+  editable;
   /**
    * Create a new component.
    *
@@ -504,6 +1000,7 @@ class A {
    * @param rotation - Orientation angle (integer degrees)
    * @param pins - Array of pin ENode UUIDs
    *
+   * @param editable
    * @example
    * ```typescript
    * // Usually created via Circuit:
@@ -522,21 +1019,21 @@ class A {
    * );
    * ```
    */
-  constructor(t, e, r, i) {
-    if (this.id = I(), this.type = t, this.position = e, this.rotation = r, new Set(i).size !== i.length) {
-      const o = i.filter((a, c) => i.indexOf(a) !== c);
+  constructor(t, e, i, n, r = !0) {
+    if (this.id = O(), this.type = t, this.position = e, this.rotation = i, new Set(n).size !== n.length) {
+      const a = n.filter((c, h) => n.indexOf(c) !== h);
       throw new Error(
-        `Duplicate pin names are not allowed: ${[...new Set(o)].join(", ")}`
+        `Duplicate pin names are not allowed: ${[...new Set(a)].join(", ")}`
       );
     }
-    this.pins = i, this.config = new Map(E[t].config);
+    this.pins = n, this.config = new Map(I[t].config), this.editable = r;
   }
   getPinLabel(t) {
     const e = this.pins.indexOf(t);
     if (e === -1)
       return;
-    const r = N(this.type).pins.keys();
-    return Array.from(r)[e] || void 0;
+    const i = I[this.type].pins.keys();
+    return Array.from(i)[e] || void 0;
   }
   setAllParameters(t) {
     this.config = new Map(t);
@@ -607,7 +1104,8 @@ class A {
       position: this.position.toJSON(),
       rotation: this.rotation.toJSON(),
       pins: [...this.pins],
-      config: Object.fromEntries(this.config)
+      config: Object.fromEntries(this.config),
+      editable: this.editable
     };
   }
   /**
@@ -616,27 +1114,14 @@ class A {
    * @param json - Component data
    * @returns Component instance
    *
-   * @example
-   * ```typescript
-   * const json = {
-   *   id: "550e8400-...",
-   *   type: "battery",
-   *   position: { x: 10, y: 20 },
-   *   rotation: 90,
-   *   pins: ['1b4f6f3c-ce ....', '2c5e7g4d-df ...'],
-   *   config: { "voltage": "5V" }
-   * };
-   *
-   * const component = Component.fromJSON(json);
-   * console.log(component.position.x); // 10
-   * ```
    */
   static fromJSON(t) {
-    const e = new A(
+    const e = new E(
       t.type,
-      v.fromJSON(t.position),
+      T.fromJSON(t.position),
       C.fromJSON(t.rotation),
-      t.pins
+      t.pins,
+      t.editable
     );
     return e.config = new Map(Object.entries(t.config)), Object.defineProperty(e, "id", {
       value: t.id,
@@ -646,207 +1131,107 @@ class A {
     }), e;
   }
 }
-class b {
-  /**
-   * Current simulation step number (starts at 0).
-   * @readonly
-   */
-  tick;
-  /**
-   * Electrical state for each ENode (component pins and branching points).
-   * Key: ENode UUID, Value: NodeElectricalState
-   * @readonly
-   */
-  nodeStates;
-  /**
-   * Electrical state for each Wire connecting ENodes.
-   * Key: Wire UUID, Value: NodeElectricalState
-   * @readonly
-   */
-  wireStates;
+const F = {
   /**
-   * Component-specific state for each component.
-   * Key: Component UUID, Value: ComponentState subclass
-   * @readonly
-   */
-  componentStates;
-  /**
-   * Create a new simulation state snapshot.
-   *
-   * @param tick - Current simulation step number
-   */
-  constructor(t) {
-    if (t < 0 || !Number.isInteger(t))
-      throw new RangeError(`Tick must be a non-negative integer (got ${t})`);
-    this.tick = t, this.nodeStates = /* @__PURE__ */ new Map(), this.wireStates = /* @__PURE__ */ new Map(), this.componentStates = /* @__PURE__ */ new Map();
-  }
-  setTick(t) {
-    this.tick = t;
-  }
-  /**
-   * Create a deep copy of this state for historical storage.
-   *
-   * @returns Cloned SimulationState
-   */
-  clone() {
-    const t = new b(this.tick), e = /* @__PURE__ */ new Map();
-    for (const [o, a] of this.nodeStates.entries())
-      e.set(o, { ...a });
-    const r = /* @__PURE__ */ new Map();
-    for (const [o, a] of this.wireStates.entries())
-      r.set(o, { ...a });
-    const i = /* @__PURE__ */ new Map();
-    for (const [o, a] of this.componentStates.entries())
-      i.set(
-        o,
-        Object.assign(Object.create(Object.getPrototypeOf(a)), a)
-      );
-    return Object.defineProperty(t, "nodeStates", {
-      value: e,
-      writable: !1,
-      configurable: !1,
-      enumerable: !0
-    }), Object.defineProperty(t, "wireStates", {
-      value: r,
-      writable: !1,
-      configurable: !1,
-      enumerable: !0
-    }), Object.defineProperty(t, "componentStates", {
-      value: i,
-      writable: !1,
-      configurable: !1,
-      enumerable: !0
-    }), t;
-  }
-}
-class R {
-  currentState;
-  history;
-  historyEnabled;
-  historyLimit;
-  historyWriteIndex;
-  /**
-   * Create a new state controllerType.
-   *
-   * @param enableHistory - Whether to store state history (default: false)
-   * @param historyLimit - Maximum number of historical states to keep (default: 1000)
-   */
-  constructor(t = !1, e = 1e3) {
-    if (e < 1)
-      throw new RangeError(`historyLimit must be at least 1 (got ${e})`);
-    this.historyEnabled = t, this.historyLimit = e, this.currentState = new b(0), this.history = [], this.historyWriteIndex = 0;
-  }
-  /**
-   * Get the current simulation state.
-   *
-   * @returns Current state (mutable for simulation controller use)
-   */
-  getCurrentState() {
-    return this.currentState;
-  }
-  /**
-   * Get current tick number.
-   *
-   * @returns Current simulation tick
+   * Minimum simulation speed in ticks per second
    */
-  getCurrentTick() {
-    return this.currentState.tick;
-  }
-  /**
-   * Advance to next tick, optionally saving current state to history.
-   * Creates a new SimulationState for the next tick.
-   *
-   * @returns New current state for the next tick
+  MIN_TPS: 1,
+  /**
+   * Maximum simulation speed in ticks per second
    */
-  advanceToNextTick() {
-    const t = this.currentState.tick + 1;
-    return this.historyEnabled && this.saveToHistory(this.currentState.clone()), this.currentState.tick = t, this.currentState;
-  }
+  MAX_TPS: 50,
   /**
-   * Get a historical state by tick number.
-   * Only works if history is enabled.
-   *
-   * @param tick - Tick number to retrieve
-   * @returns State at that tick, or undefined if not available
+   * Default simulation speed in ticks per second
    */
-  getStateAtTick(t) {
-    if (this.historyEnabled)
-      return this.history.find((e) => e.tick === t);
-  }
+  DEFAULT_TPS: 3,
   /**
-   * Get all available historical states.
-   * Returns empty array if history is disabled.
-   *
-   * @returns Array of historical states, sorted by tick (oldest first)
+   * Default tick interval in milliseconds (1000 / DEFAULT_TPS)
    */
-  getHistory() {
-    return this.historyEnabled ? [...this.history].sort((t, e) => t.tick - e.tick) : [];
-  }
+  DEFAULT_INTERVAL_MS: 500
+}, $ = {
   /**
-   * Get the oldest tick number available in history.
-   *
-   * @returns Oldest tick number, or undefined if no history
+   * Default transitionSpan for relays and transistors in ticks (instant transition)
    */
-  getOldestTick() {
-    if (!(!this.historyEnabled || this.history.length === 0))
-      return Math.min(...this.history.map((t) => t.tick));
-  }
+  TRANSITION_SPAN_TICKS: 1,
   /**
-   * Get the newest tick number in history (not including current tick).
-   *
-   * @returns Newest historical tick, or undefined if no history
+   * Default transitionUserSpan for switches in milliseconds
    */
-  getNewestHistoricalTick() {
-    if (!(!this.historyEnabled || this.history.length === 0))
-      return Math.max(...this.history.map((t) => t.tick));
-  }
+  TRANSITION_USER_SPAN_MS: 200
+};
+class w {
   /**
-   * Clear all history.
+   * Current simulation step number (starts at 0).
+   * @readonly
    */
-  clearHistory() {
-    this.history = [], this.historyWriteIndex = 0;
-  }
+  tick;
   /**
-   * Reset to tick 0, clearing current state and all history.
+   * Electrical state for each ENode (component pins and branching points).
+   * Key: ENode UUID, Value: INodeElectricalState
+   * @readonly
    */
-  reset() {
-    this.currentState = new b(0), this.clearHistory();
-  }
+  nodeStates;
   /**
-   * Check if history tracking is enabled.
-   *
-   * @returns True if history is enabled
+   * Electrical state for each Wire connecting ENodes.
+   * Key: Wire UUID, Value: INodeElectricalState
+   * @readonly
    */
-  isHistoryEnabled() {
-    return this.historyEnabled;
-  }
+  wireStates;
   /**
-   * Get the configured history limit.
-   *
-   * @returns Maximum number of historical states
+   * Component-specific state for each component.
+   * Key: Component UUID, Value: ComponentState subclass
+   * @readonly
    */
-  getHistoryLimit() {
-    return this.historyLimit;
-  }
+  componentStates;
   /**
-   * Get current history size.
+   * Create a new simulation state snapshot.
    *
-   * @returns Number of states in history
+   * @param tick - Current simulation step number
    */
-  getHistorySize() {
-    return this.history.length;
+  constructor(t) {
+    if (t < 0 || !Number.isInteger(t))
+      throw new RangeError(`Tick must be a non-negative integer (got ${t})`);
+    this.tick = t, this.nodeStates = /* @__PURE__ */ new Map(), this.wireStates = /* @__PURE__ */ new Map(), this.componentStates = /* @__PURE__ */ new Map();
+  }
+  setTick(t) {
+    this.tick = t;
   }
   /**
-   * Save a state to history using circular buffer.
-   * Private helper for advanceToNextTick.
+   * Create a deep copy of this state for historical storage.
    *
-   * @param state - State to save
+   * @returns Cloned SimulationState
    */
-  saveToHistory(t) {
-    this.history.length < this.historyLimit ? this.history.push(t) : (this.history[this.historyWriteIndex] = t, this.historyWriteIndex = (this.historyWriteIndex + 1) % this.historyLimit);
+  clone() {
+    const t = new w(this.tick), e = /* @__PURE__ */ new Map();
+    for (const [r, a] of this.nodeStates.entries())
+      e.set(r, { ...a });
+    const i = /* @__PURE__ */ new Map();
+    for (const [r, a] of this.wireStates.entries())
+      i.set(r, { ...a });
+    const n = /* @__PURE__ */ new Map();
+    for (const [r, a] of this.componentStates.entries())
+      n.set(
+        r,
+        Object.assign(Object.create(Object.getPrototypeOf(a)), a)
+      );
+    return Object.defineProperty(t, "nodeStates", {
+      value: e,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "wireStates", {
+      value: i,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "componentStates", {
+      value: n,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), t;
   }
 }
-class x {
+class D {
   heap;
   /**
    * Create a new empty event queue.
@@ -878,10 +1263,10 @@ class x {
   getReadyEvents(t) {
     const e = [];
     for (; this.heap.length > 0 && this.heap[0].readyAtTick <= t; ) {
-      const r = this.extractMin();
-      r && e.push(r);
+      const i = this.extractMin();
+      i && e.push(i);
     }
-    return e.sort((r, i) => r.readyAtTick === i.readyAtTick ? r.scheduledAtTick - i.scheduledAtTick : r.readyAtTick - i.readyAtTick), e;
+    return e.sort((i, n) => i.readyAtTick === n.readyAtTick ? i.scheduledAtTick - n.scheduledAtTick : i.readyAtTick - n.readyAtTick), e;
   }
   /**
    * Check if any events are pending.
@@ -897,6 +1282,17 @@ class x {
   clear() {
     this.heap = [];
   }
+  /**
+   * Remove all pending events targeting a specific component.
+   * Used when a behavior signals shouldCancelPending (e.g., Vcc loss, input change during transition).
+   *
+   * @param targetId - UUID of the component whose events should be removed
+   * @returns Number of events removed
+   */
+  removeEventsForTarget(t) {
+    const e = this.heap.length;
+    return this.heap = this.heap.filter((i) => i.targetId !== t), this.heap.length !== e && this.rebuildHeap(), e - this.heap.length;
+  }
   /**
    * Get number of pending events.
    *
@@ -905,6 +1301,10 @@ class x {
   size() {
     return this.heap.length;
   }
+  rebuildHeap() {
+    for (let t = Math.floor(this.heap.length / 2) - 1; t >= 0; t--)
+      this.bubbleDown(t);
+  }
   bubbleUp(t) {
     for (; t > 0; ) {
       const e = Math.floor((t - 1) / 2);
@@ -917,10 +1317,10 @@ class x {
   bubbleDown(t) {
     const e = this.heap.length;
     for (; ; ) {
-      const r = 2 * t + 1, i = 2 * t + 2;
-      let o = t;
-      if (r < e && this.heap[r].readyAtTick < this.heap[o].readyAtTick && (o = r), i < e && this.heap[i].readyAtTick < this.heap[o].readyAtTick && (o = i), o !== t)
-        [this.heap[t], this.heap[o]] = [this.heap[o], this.heap[t]], t = o;
+      const i = 2 * t + 1, n = 2 * t + 2;
+      let r = t;
+      if (i < e && this.heap[i].readyAtTick < this.heap[r].readyAtTick && (r = i), n < e && this.heap[n].readyAtTick < this.heap[r].readyAtTick && (r = n), r !== t)
+        [this.heap[t], this.heap[r]] = [this.heap[r], this.heap[t]], t = r;
       else
         break;
     }
@@ -1040,33 +1440,133 @@ class P {
     return this.dirtyEnodes.size;
   }
 }
-const U = {
+class x {
+  currentState;
+  history;
+  historyEnabled;
+  historyLimit;
+  historyWriteIndex;
   /**
-   * Minimum simulation speed in ticks per second
+   * Create a new state controllerType.
+   *
+   * @param enableHistory - Whether to store state history (default: false)
+   * @param historyLimit - Maximum number of historical states to keep (default: 1000)
    */
-  MIN_TPS: 1,
+  constructor(t = !1, e = 1e3) {
+    if (e < 1)
+      throw new RangeError(`historyLimit must be at least 1 (got ${e})`);
+    this.historyEnabled = t, this.historyLimit = e, this.currentState = new w(0), this.history = [], this.historyWriteIndex = 0;
+  }
   /**
-   * Maximum simulation speed in ticks per second
+   * Get the current simulation state.
+   *
+   * @returns Current state (mutable for simulation controller use)
    */
-  MAX_TPS: 50,
+  getCurrentState() {
+    return this.currentState;
+  }
   /**
-   * Default simulation speed in ticks per second
+   * Get current tick number.
+   *
+   * @returns Current simulation tick
    */
-  DEFAULT_TPS: 3,
+  getCurrentTick() {
+    return this.currentState.tick;
+  }
   /**
-   * Default tick interval in milliseconds (1000 / DEFAULT_TPS)
+   * Advance to next tick, optionally saving current state to history.
+   * Creates a new SimulationState for the next tick.
+   *
+   * @returns New current state for the next tick
    */
-  DEFAULT_INTERVAL_MS: 500
-}, $ = {
+  advanceToNextTick() {
+    const t = this.currentState.tick + 1;
+    return this.historyEnabled && this.saveToHistory(this.currentState.clone()), this.currentState.tick = t, this.currentState;
+  }
   /**
-   * Default transitionSpan for relays and transistors in ticks (instant transition)
+   * Get a historical state by tick number.
+   * Only works if history is enabled.
+   *
+   * @param tick - Tick number to retrieve
+   * @returns State at that tick, or undefined if not available
    */
-  TRANSITION_SPAN_TICKS: 1,
+  getStateAtTick(t) {
+    if (this.historyEnabled)
+      return this.history.find((e) => e.tick === t);
+  }
   /**
-   * Default transitionUserSpan for switches in milliseconds
+   * Get all available historical states.
+   * Returns empty array if history is disabled.
+   *
+   * @returns Array of historical states, sorted by tick (oldest first)
    */
-  TRANSITION_USER_SPAN_MS: 200
-};
+  getHistory() {
+    return this.historyEnabled ? [...this.history].sort((t, e) => t.tick - e.tick) : [];
+  }
+  /**
+   * Get the oldest tick number available in history.
+   *
+   * @returns Oldest tick number, or undefined if no history
+   */
+  getOldestTick() {
+    if (!(!this.historyEnabled || this.history.length === 0))
+      return Math.min(...this.history.map((t) => t.tick));
+  }
+  /**
+   * Get the newest tick number in history (not including current tick).
+   *
+   * @returns Newest historical tick, or undefined if no history
+   */
+  getNewestHistoricalTick() {
+    if (!(!this.historyEnabled || this.history.length === 0))
+      return Math.max(...this.history.map((t) => t.tick));
+  }
+  /**
+   * Clear all history.
+   */
+  clearHistory() {
+    this.history = [], this.historyWriteIndex = 0;
+  }
+  /**
+   * Reset to tick 0, clearing current state and all history.
+   */
+  reset() {
+    this.currentState = new w(0), this.clearHistory();
+  }
+  /**
+   * Check if history tracking is enabled.
+   *
+   * @returns True if history is enabled
+   */
+  isHistoryEnabled() {
+    return this.historyEnabled;
+  }
+  /**
+   * Get the configured history limit.
+   *
+   * @returns Maximum number of historical states
+   */
+  getHistoryLimit() {
+    return this.historyLimit;
+  }
+  /**
+   * Get current history size.
+   *
+   * @returns Number of states in history
+   */
+  getHistorySize() {
+    return this.history.length;
+  }
+  /**
+   * Save a state to history using circular buffer.
+   * Private helper for advanceToNextTick.
+   *
+   * @param state - State to save
+   */
+  saveToHistory(t) {
+    this.history.length < this.historyLimit ? this.history.push(t) : (this.history[this.historyWriteIndex] = t, this.historyWriteIndex = (this.historyWriteIndex + 1) % this.historyLimit);
+  }
+}
 class J {
   circuit;
   stateManager;
@@ -1081,10 +1581,10 @@ class J {
    * @param behaviorRegistry - Registry of component behaviors
    * @param options - Simulation options (history settings)
    */
-  constructor(t, e, r = {}) {
+  constructor(t, e, i = {}) {
     this.circuit = t, this.behaviorRegistry = e;
-    const i = r.enableHistory ?? !1, o = r.historyLimit ?? 1e3;
-    this.stateManager = new R(i, o), this.eventQueue = new x(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new P();
+    const n = i.enableHistory ?? !1, r = i.historyLimit ?? 1e3;
+    this.stateManager = new x(n, r), this.eventQueue = new D(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new P();
     try {
       this.initializeState();
     } catch (a) {
@@ -1098,25 +1598,25 @@ class J {
    * @returns the result of the tick execution
    */
   tick() {
-    const t = this.eventQueue.size(), e = this.stateManager.getCurrentTick(), r = this.applyReadyEvents(e + 1), i = this.updateState(e + 1);
-    i.firedEventCount = r.length;
-    const o = this.processCommands();
-    i.processedCommandCount = o.length, i.scheduledEventCount = this.eventQueue.size() + i.firedEventCount - t;
-    for (const a of r)
+    const t = this.eventQueue.size(), e = this.stateManager.getCurrentTick(), i = this.applyReadyEvents(e + 1), n = this.updateState(e + 1);
+    n.firedEventCount = i.length;
+    const r = this.processCommands();
+    n.processedCommandCount = r.length, n.scheduledEventCount = this.eventQueue.size() + n.firedEventCount - t;
+    for (const a of i)
       a.hasChanged && this.dirtyTracker.markComponentDirty(a.componentState.componentId);
-    return i.componentUpdateCount = this.dirtyTracker.getDirtyComponentCount(), this.stateManager.advanceToNextTick(), i.endTick = this.stateManager.getCurrentTick(), i;
+    return n.componentUpdateCount = this.dirtyTracker.getDirtyComponentCount(), this.stateManager.advanceToNextTick(), n.endTick = this.stateManager.getCurrentTick(), n;
   }
   /**
    * Execute multiple simulation ticks.
    *
    * @param count - Number of ticks to execute
-   * @returns an array of RunnerResult for each tick executed
+   * @returns an array of IRunnerResult for each tick executed
    */
   tickN(t) {
     if (t < 1)
       throw new RangeError(`Tick count must be at least 1 (got ${t})`);
     const e = [];
-    for (let r = 0; r < t; r++)
+    for (let i = 0; i < t; i++)
       e.push(this.tick());
     return e;
   }
@@ -1206,19 +1706,20 @@ class J {
    * Mark changed components as Dirty and enqueue consequent scheduled events
    * Finally clears command queue after processing.
    *
-   * @returns Array of BehaviorResult for each processed command
+   * @returns Array of IBehaviorResult for each processed command
    */
   processCommands() {
     const t = this.stateManager.getCurrentState(), e = [];
-    for (const r of this.commands.values()) {
-      const i = this.circuit.getComponent(r.targetId), a = this.behaviorRegistry.get(i.type).onUserCommand(
-        i,
-        t.componentStates.get(i.id),
-        r
+    for (const i of this.commands.values()) {
+      const n = this.circuit.getComponent(i.targetId), a = this.behaviorRegistry.get(n.type).onUserCommand(
+        n,
+        t.componentStates.get(n.id),
+        i
       );
+      a.shouldCancelPending && this.eventQueue.removeEventsForTarget(n.id);
       for (const c of a.scheduledEvents)
         this.eventQueue.schedule(c);
-      e.push(a), a.hasChanged && this.dirtyTracker.markComponentDirty(i.id);
+      e.push(a), a.hasChanged && this.dirtyTracker.markComponentDirty(n.id);
     }
     return this.commands.clear(), e;
   }
@@ -1232,8 +1733,8 @@ class J {
   getInitializationOrder(t) {
     const e = t.get("initializationOrder");
     if (!e || e === "") return 0;
-    const r = parseInt(e, 10);
-    return isNaN(r) ? 0 : r;
+    const i = parseInt(e, 10);
+    return isNaN(i) ? 0 : i;
   }
   /**
    * Initialize simulation state for all components.
@@ -1252,16 +1753,16 @@ class J {
     const t = this.stateManager.getCurrentState();
     for (const s of this.circuit.getAllComponents()) {
       if (s.pins.length < 1) continue;
-      const h = this.behaviorRegistry.get(s.type);
-      if (!h)
+      const u = this.behaviorRegistry.get(s.type);
+      if (!u)
         continue;
-      const u = h.createInitialState(s);
-      t.componentStates.set(s.id, u), this.dirtyTracker.markComponentDirty(s.id);
+      const d = u.createInitialState(s);
+      t.componentStates.set(s.id, d), this.dirtyTracker.markComponentDirty(s.id);
     }
     for (const s of this.circuit.getAllENodes())
       t.nodeStates.set(s.id, {
-        hasVoltage: s.source === S.Voltage,
-        hasCurrent: s.source === S.Current,
+        hasVoltage: s.source === v.Voltage,
+        hasCurrent: s.source === v.Current,
         locked: !!s.source
       });
     for (const s of this.circuit.getAllWires())
@@ -1270,50 +1771,50 @@ class J {
         hasCurrent: !1,
         locked: !1
       });
-    const e = this.circuit.getAllComponents(), r = /* @__PURE__ */ new Map();
+    const e = this.circuit.getAllComponents(), i = /* @__PURE__ */ new Map();
     for (const s of e) {
-      const h = this.getInitializationOrder(s.config), u = r.get(h) ?? [];
-      u.push(s), r.set(h, u);
+      const u = this.getInitializationOrder(s.config), d = i.get(u) ?? [];
+      d.push(s), i.set(u, d);
     }
-    const i = Array.from(r.keys()).sort((s, h) => s - h);
-    for (const s of i)
-      r.get(s).sort((u, g) => u.id.localeCompare(g.id));
-    let o = !0, a = 0;
+    const n = Array.from(i.keys()).sort((s, u) => s - u);
+    for (const s of n)
+      i.get(s).sort((d, l) => d.id.localeCompare(l.id));
+    let r = !0, a = 0;
     const c = 100;
-    for (; o && a < c; ) {
-      o = !1, a++;
-      for (const s of i) {
-        const h = r.get(s);
-        for (const u of h) {
-          const g = this.behaviorRegistry.get(u.type);
+    for (; r && a < c; ) {
+      r = !1, a++;
+      for (const s of n) {
+        const u = i.get(s);
+        for (const d of u) {
+          const l = this.behaviorRegistry.get(d.type);
+          if (!l) continue;
+          const g = t.componentStates.get(d.id);
           if (!g) continue;
-          const f = t.componentStates.get(u.id);
-          if (!f) continue;
           this.propagateConductivity();
-          const m = g.onPinsChange(
-            u,
-            f,
+          const b = l.onPinsChange(
+            d,
+            g,
             t.nodeStates,
             0
           );
-          m.hasChanged && (o = !0, t.componentStates.set(
-            u.id,
-            m.componentState
+          b.hasChanged && (r = !0, t.componentStates.set(
+            d.id,
+            b.componentState
           ));
-          for (const y of m.scheduledEvents) {
-            const d = g.onEventFiring(u, f, y);
-            d.hasChanged && (o = !0, t.componentStates.set(
-              u.id,
-              d.componentState
+          for (const f of b.scheduledEvents) {
+            const p = l.onEventFiring(d, g, f);
+            p.hasChanged && (r = !0, t.componentStates.set(
+              d.id,
+              p.componentState
             ));
           }
         }
       }
     }
-    const l = this.updateState(0);
+    const h = this.updateState(0);
     return this.dirtyTracker.setDirtyComponents(
       /* @__PURE__ */ new Set([...this.circuit.getAllComponents().map((s) => s.id)])
-    ), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((s) => s.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((s) => s.id)])), l;
+    ), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((s) => s.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((s) => s.id)])), h;
   }
   /**
    * Core method that orchestrates nodes, wires and components state updates
@@ -1321,32 +1822,32 @@ class J {
    * @param targetTick - Tick at which to perform the update
    */
   updateState(t) {
-    const e = this.stateManager.getCurrentState(), { updatedNodes: r, updatedWires: i } = this.propagateConductivity(), o = this.circuit.getComponentsOfPins(r), a = /* @__PURE__ */ new Set();
-    let c = 0, l = Array.from(o);
-    t === 0 && (l = l.sort((s, h) => {
-      const u = this.circuit.getComponent(s), g = this.circuit.getComponent(h), f = this.getInitializationOrder(u.config), m = this.getInitializationOrder(g.config);
-      return f !== m ? f - m : s.localeCompare(h);
+    const e = this.stateManager.getCurrentState(), { updatedNodes: i, updatedWires: n } = this.propagateConductivity(), r = this.circuit.getComponentsOfPins(i), a = /* @__PURE__ */ new Set();
+    let c = 0, h = Array.from(r);
+    t === 0 && (h = h.sort((s, u) => {
+      const d = this.circuit.getComponent(s), l = this.circuit.getComponent(u), g = this.getInitializationOrder(d.config), b = this.getInitializationOrder(l.config);
+      return g !== b ? g - b : s.localeCompare(u);
     }));
-    for (const s of l) {
-      const h = this.circuit.getComponent(s), u = this.behaviorRegistry.get(h.type);
-      if (!u)
+    for (const s of h) {
+      const u = this.circuit.getComponent(s), d = this.behaviorRegistry.get(u.type);
+      if (!d)
         continue;
-      const g = u.onPinsChange(
-        h,
+      const l = d.onPinsChange(
+        u,
         e.componentStates.get(s),
         e.nodeStates,
         t
       );
-      g.hasChanged && a.add(s);
-      for (const f of g.scheduledEvents)
-        this.eventQueue.schedule(f), c++;
+      l.shouldCancelPending && this.eventQueue.removeEventsForTarget(s), l.hasChanged && a.add(s);
+      for (const g of l.scheduledEvents)
+        this.eventQueue.schedule(g), c++;
     }
-    return this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(r), this.dirtyTracker.setDirtyWires(i), {
+    return this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(i), this.dirtyTracker.setDirtyWires(n), {
       startTick: this.getCurrentTick(),
       endTick: this.getCurrentTick(),
       componentUpdateCount: a.size,
-      nodeUpdateCount: r.size,
-      wireUpdateCount: i.size,
+      nodeUpdateCount: i.size,
+      wireUpdateCount: n.size,
       processedCommandCount: 0,
       scheduledEventCount: c,
       firedEventCount: 0
@@ -1360,34 +1861,34 @@ class J {
    */
   propagateConductivity() {
     const t = this.stateManager.getCurrentState(), e = (c) => {
-      const l = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), h = this.circuit.getAllENodes().filter((d) => d.source == c).map((d) => d.id), u = /* @__PURE__ */ new Set([
-        ...this.circuit.getAllENodes().filter((d) => !d.source).map((d) => d.id)
-      ]), g = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((d) => d.id)]), { nodes: f, wires: m } = this.computeReachability(
+      const h = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), u = this.circuit.getAllENodes().filter((p) => p.source == c).map((p) => p.id), d = /* @__PURE__ */ new Set([
+        ...this.circuit.getAllENodes().filter((p) => !p.source).map((p) => p.id)
+      ]), l = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((p) => p.id)]), { nodes: g, wires: b } = this.computeReachability(
         c,
-        h,
+        u,
         t.componentStates
-      ), y = c == S.Voltage ? "hasVoltage" : "hasCurrent";
-      for (const d of f) {
-        const p = t.nodeStates.get(d);
-        p && !p.locked && (p[y] || (p[y] = !0, l.add(d)), u.delete(d));
+      ), f = c == v.Voltage ? "hasVoltage" : "hasCurrent";
+      for (const p of g) {
+        const y = t.nodeStates.get(p);
+        y && !y.locked && (y[f] || (y[f] = !0, h.add(p)), d.delete(p));
       }
-      for (const d of u) {
-        const p = t.nodeStates.get(d);
-        p && !p.locked && p[y] && (p[y] = !1, l.add(d));
+      for (const p of d) {
+        const y = t.nodeStates.get(p);
+        y && !y.locked && y[f] && (y[f] = !1, h.add(p));
       }
-      for (const d of m) {
-        const p = t.wireStates.get(d);
-        p && (p[y] || (p[y] = !0, s.add(d)), g.delete(d));
+      for (const p of b) {
+        const y = t.wireStates.get(p);
+        y && (y[f] || (y[f] = !0, s.add(p)), l.delete(p));
       }
-      for (const d of g) {
-        const p = t.wireStates.get(d);
-        p && p[y] && (p[y] = !1, s.add(d));
+      for (const p of l) {
+        const y = t.wireStates.get(p);
+        y && y[f] && (y[f] = !1, s.add(p));
       }
-      return { updatedNodes: l, updatedWires: s };
-    }, { updatedNodes: r, updatedWires: i } = e(S.Voltage), { updatedNodes: o, updatedWires: a } = e(S.Current);
+      return { updatedNodes: h, updatedWires: s };
+    }, { updatedNodes: i, updatedWires: n } = e(v.Voltage), { updatedNodes: r, updatedWires: a } = e(v.Current);
     return {
-      updatedNodes: /* @__PURE__ */ new Set([...r, ...o]),
-      updatedWires: /* @__PURE__ */ new Set([...i, ...a])
+      updatedNodes: /* @__PURE__ */ new Set([...i, ...r]),
+      updatedWires: /* @__PURE__ */ new Set([...n, ...a])
     };
   }
   /**
@@ -1398,35 +1899,35 @@ class J {
    * @param seeds
    * @param componentStates
    */
-  computeReachability(t, e, r) {
-    const i = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), a = [];
+  computeReachability(t, e, i) {
+    const n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), a = [];
     for (const c of e)
-      a.push(c), i.add(c);
+      a.push(c), n.add(c);
     for (; a.length > 0; ) {
       const c = a.shift();
       for (const s of this.circuit.getWiresByNode(c)) {
-        const h = s.node1 === c ? s.node2 : s.node1;
-        i.has(h) || (i.add(h), a.push(h)), o.has(s.id) || o.add(s.id);
+        const u = s.node1 === c ? s.node2 : s.node1;
+        n.has(u) || (n.add(u), a.push(u)), r.has(s.id) || r.add(s.id);
       }
-      const l = this.circuit.getENode(c);
-      if (l.type === M.Pin) {
-        const s = this.circuit.getComponent(l.component), h = this.behaviorRegistry.get(s.type);
-        if (!h)
+      const h = this.circuit.getENode(c);
+      if (h.type === S.Pin) {
+        const s = this.circuit.getComponent(h.component), u = this.behaviorRegistry.get(s.type);
+        if (!u)
           continue;
-        const u = r.get(s.id);
-        for (const g of s.pins) {
-          if (g === c || i.has(g)) continue;
-          h.allowConductivity(
+        const d = i.get(s.id);
+        for (const l of s.pins) {
+          if (l === c || n.has(l)) continue;
+          u.allowConductivity(
             s,
-            u,
+            d,
             t,
             c,
-            g
-          ) && (i.add(g), a.push(g));
+            l
+          ) && (n.add(l), a.push(l));
         }
       }
     }
-    return { nodes: i, wires: o };
+    return { nodes: n, wires: r };
   }
   /**
    * Fire ready events and update current state accordingly
@@ -1438,40 +1939,43 @@ class J {
    * @param targetTick - Target tick for event processing
    */
   applyReadyEvents(t) {
-    const e = this.stateManager.getCurrentState(), r = this.eventQueue.getReadyEvents(t), i = [];
-    for (const o of r) {
-      const a = this.circuit.getComponent(o.targetId), c = this.behaviorRegistry.get(a.type);
+    const e = this.stateManager.getCurrentState(), i = this.eventQueue.getReadyEvents(t), n = [];
+    for (const r of i) {
+      const a = this.circuit.getComponent(r.targetId), c = this.behaviorRegistry.get(a.type);
       if (!c)
         continue;
-      const l = e.componentStates.get(a.id), s = c.onEventFiring(a, l, o);
-      for (const h of s.scheduledEvents)
-        this.eventQueue.schedule(h);
-      i.push(s);
+      const h = e.componentStates.get(a.id), s = c.onEventFiring(a, h, r);
+      s.shouldCancelPending && this.eventQueue.removeEventsForTarget(a.id);
+      for (const u of s.scheduledEvents)
+        this.eventQueue.schedule(u);
+      n.push(s);
     }
-    return i;
+    return n;
   }
 }
 export {
-  k as C,
-  P as D,
-  S as E,
-  v as P,
+  W as A,
+  M as C,
+  U as D,
+  v as E,
+  T as P,
   C as R,
-  b as S,
+  F as S,
   $ as T,
-  T as a,
-  E as b,
-  N as c,
-  M as d,
-  I as e,
-  W as f,
-  z as g,
-  w as h,
-  A as i,
-  J as j,
-  R as k,
-  U as l,
-  x as m,
-  L as s
+  m as a,
+  G as b,
+  L as c,
+  I as d,
+  S as e,
+  R as f,
+  O as g,
+  k as h,
+  E as i,
+  D as j,
+  P as k,
+  x as l,
+  J as m,
+  w as n,
+  z as s
 };
-//# sourceMappingURL=CircuitRunner-FXM_s5ll.js.map
+//# sourceMappingURL=CircuitRunner-BQQlhwjD.js.map