simple-circuit-engine 0.0.10 → 0.0.11

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

@@ -1,4 +1,4 @@
-class w {
+class m {
   /**
    * Create a new 3D 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.
@@ -78,8 +78,8 @@ class M {
    * @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), i = 75, n = 0.1, s = 1e3) {
-    this.position = t, this.lookAtPosition = e, this.fov = i, this.near = n, this.far = s;
+  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.
@@ -130,8 +130,8 @@ class M {
    */
   static fromJSON(t) {
     return new M(
-      w.fromJSON(t.position),
-      w.fromJSON(t.lookAtPosition),
+      m.fromJSON(t.position),
+      m.fromJSON(t.lookAtPosition),
       t.fov,
       t.near,
       t.far
@@ -146,266 +146,7 @@ class M {
     return `CameraOptions(position: ${this.position.toString()}, lookAt: ${this.lookAtPosition.toString()}, fov: ${this.fov}, near: ${this.near}, far: ${this.far})`;
   }
 }
-var v = /* @__PURE__ */ ((r) => (r.Voltage = "Voltage", r.Current = "Current", r))(v || {}), E = /* @__PURE__ */ ((r) => (r.Cube = "cube", r.Label = "label", r.Battery = "battery", r.Switch = "switch", r.Lightbulb = "lightbulb", r.Relay = "relay", r.Transistor = "transistor", r.Buffer = "buffer", r.SmallLED = "smallLED", r.RectangleLED = "rectangleLED", r.AndGate = "andGate", r.And4Gate = "and4Gate", r.And8Gate = "and8Gate", r.OrGate = "orGate", r.Or4Gate = "or4Gate", r.Or8Gate = "or8Gate", r.XorGate = "xorGate", r))(E || {});
-const O = {
-  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", v.Voltage],
-      ["anode", v.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", ""]
-    ])
-  },
-  buffer: {
-    id: "buffer",
-    name: "Buffer",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input", void 0],
-      ["output", 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"]
-    ])
-  },
-  andGate: {
-    id: "andGate",
-    name: "AND Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  and4Gate: {
-    id: "and4Gate",
-    name: "AND4 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["input3", void 0],
-      ["input4", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  and8Gate: {
-    id: "and8Gate",
-    name: "AND8 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["input3", void 0],
-      ["input4", void 0],
-      ["input5", void 0],
-      ["input6", void 0],
-      ["input7", void 0],
-      ["input8", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  orGate: {
-    id: "orGate",
-    name: "OR Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  or4Gate: {
-    id: "or4Gate",
-    name: "OR4 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["input3", void 0],
-      ["input4", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  or8Gate: {
-    id: "or8Gate",
-    name: "OR8 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["input3", void 0],
-      ["input4", void 0],
-      ["input5", void 0],
-      ["input6", void 0],
-      ["input7", void 0],
-      ["input8", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  xorGate: {
-    id: "xorGate",
-    name: "XOR Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", void 0],
-      ["input1", void 0],
-      ["input2", void 0],
-      ["output", void 0]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["transitionSpan", "2"],
-      // default transition span is twice the default transition span (1) of the 3 underlying gates (2 layers in serie)
-      ["initializationOrder", ""]
-    ])
-  }
-};
-function x() {
-  return Object.values(E);
-}
-function I(r) {
-  return O[r];
-}
-var S = /* @__PURE__ */ ((r) => (r.Pin = "Pin", r.BranchingPoint = "BranchingPoint", r))(S || {});
-function T() {
-  if (typeof crypto < "u" && crypto.randomUUID)
-    return crypto.randomUUID();
-  const r = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
-  for (const c of t) {
-    let l = "";
-    for (let o = 0; o < c; o++) {
-      const h = Math.floor(Math.random() * 16);
-      l += r[h];
-    }
-    e.push(l);
-  }
-  const n = e.join("-").split("");
-  n[14] = "4";
-  const a = parseInt(n[19] ?? "0", 16) & 3 | 8;
-  return n[19] = r[a] ?? "0", n.join("");
-}
-class C {
+class T {
   /**
    * Create a new position on the discrete grid.
    *
@@ -466,7 +207,7 @@ class C {
    * ```
    */
   static fromJSON(t) {
-    return new C(t.x, t.y);
+    return new T(t.x, t.y);
   }
   /**
    * String representation for debugging.
@@ -477,46 +218,46 @@ class C {
     return `Position(${this.x}, ${this.y})`;
   }
 }
-function G(r, t, e = 1 / 0) {
-  if (r.length === 0)
+function R(o, t, e = 1 / 0) {
+  if (o.length === 0)
     return 0;
-  if (r.length === 1)
+  if (o.length === 1)
     return 1;
   let i = 1;
-  for (let n = 0; n < r.length - 1; n++) {
-    const s = r[n], a = r[n + 1], c = D(t, s, a);
+  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 i;
 }
-function D(r, t, e) {
-  const i = e.x - t.x, n = e.y - t.y, s = i * i + n * n;
-  if (s === 0)
-    return Math.sqrt((r.x - t.x) ** 2 + (r.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,
-      ((r.x - t.x) * i + (r.y - t.y) * n) / s
+      ((o.x - t.x) * i + (o.y - t.y) * n) / r
     )
-  ), c = t.x + a * i, l = t.y + a * n;
-  return Math.sqrt((r.x - c) ** 2 + (r.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 W(r, t = 5) {
-  if (r.length <= 2)
-    return [...r];
-  const e = [r[0]];
-  for (let i = 1; i < r.length - 1; i++) {
-    const n = e[e.length - 1], s = r[i], a = r[i + 1];
-    P(n, s, a, t) || e.push(s);
-  }
-  return e.push(r[r.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 P(r, t, e, i = 5) {
-  const n = (t.x - r.x) * (e.y - r.y) - (t.y - r.y) * (e.x - r.x);
+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 k {
+class C {
   /**
    * Create a new rotation with the specified angle.
    *
@@ -556,7 +297,7 @@ class k {
    * ```
    */
   static fromJSON(t) {
-    return new k(t);
+    return new C(t);
   }
   /**
    * Check if this rotation equals another rotation.
@@ -586,196 +327,413 @@ class k {
     return `Rotation(${this.angle}°)`;
   }
 }
-class A {
-  /**
-   * Unique identifier for this component.
-   * @readonly
-   */
-  id;
-  /**
-   * Component type (Battery, Switch, LED, etc.).
-   * @readonly
-   */
-  type;
-  /**
-   * Position on the 2D discrete grid.
-   * @readonly
-   */
-  position;
-  /**
-   * Orientation angle in degrees.
-   * @readonly
-   */
-  rotation;
-  /**
-   * Array of pin ENode UUIDs.
-   * Pin order is significant (index 0 is first pin, etc.).
-   * @readonly
-   */
-  pins;
-  /**
-   * 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.
-   *
-   */
-  config;
-  /**
-   * Create a new component.
-   *
-   * **Note**: Typically components are created via `Circuit.addComponent()`
-   * which handles pin ENode creation automatically. This constructor is used
-   * internally by Circuit.
-   *
-   * @param type - Component type (Battery, Switch, LED, etc.)
-   * @param position - Grid position (integer x, y)
-   * @param rotation - Orientation angle (integer degrees)
-   * @param pins - Array of pin ENode UUIDs
-   *
-   * @example
-   * ```typescript
-   * // Usually created via Circuit:
-   * const component = circuit.addComponent(
-   *   new Position(10, 20),
-   *   new Rotation(90),
-   *   ComponentType.Battery
-   * );
-   *
-   * // Direct construction (for deserialization):
-   * const component = new Component(
-   *   ComponentType.Battery,
-   *   new Position(10, 20),
-   *   new Rotation(90),
-   *   ['pin-id-1', 'pin-id-2']
-   * );
-   * ```
-   */
-  constructor(t, e, i, n) {
-    if (this.id = T(), this.type = t, this.position = e, this.rotation = i, new Set(n).size !== n.length) {
-      const s = n.filter((a, c) => n.indexOf(a) !== c);
-      throw new Error(
-        `Duplicate pin names are not allowed: ${[...new Set(s)].join(", ")}`
-      );
+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];
     }
-    this.pins = n, this.config = new Map(O[t].config);
-  }
-  getPinLabel(t) {
-    const e = this.pins.indexOf(t);
-    if (e === -1)
-      return;
-    const i = I(this.type).pins.keys();
-    return Array.from(i)[e] || void 0;
-  }
-  setAllParameters(t) {
-    this.config = new Map(t);
-  }
-  setParameter(t, e) {
-    this.config.set(t, e);
-  }
-  /**
-   * Update the component's position.
-   *
-   * @param newPosition - The new position for the component
-   *
-   * @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 component's rotation.
-   *
-   * @param newRotation - The new rotation for the component
-   *
-   * @example
-   * ```typescript
-   * const component = circuit.getComponent(componentId);
-   * component.setRotation(new Rotation(90));
-   * ```
-   */
-  setRotation(t) {
-    Object.defineProperty(this, "rotation", {
-      value: t,
-      writable: !1,
-      enumerable: !0,
-      configurable: !0
-    });
-  }
-  /**
-   * Serialize component to JSON.
-   *
-   * @returns Plain object representation
-   *
-   * @example
-   * ```typescript
-   * const json = component.toJSON();
-   * console.log(json);
-   * // {
-   * //   id: "550e8400-...",
-   * //   type: "battery",
-   * //   position: { x: 10, y: 20 },
-   * //   rotation: 90,
-   * //   pins: ['pin-uuid-1', 'pin-uuid-2']
-   * // }
-   * ```
-   */
-  toJSON() {
-    return {
-      id: this.id,
-      type: this.type,
-      position: this.position.toJSON(),
-      rotation: this.rotation.toJSON(),
-      pins: [...this.pins],
-      config: Object.fromEntries(this.config)
-    };
-  }
-  /**
-   * Deserialize component from JSON.
-   *
-   * @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(
-      t.type,
-      C.fromJSON(t.position),
-      k.fromJSON(t.rotation),
-      t.pins
-    );
-    return e.config = new Map(Object.entries(t.config)), Object.defineProperty(e, "id", {
-      value: t.id,
-      writable: !1,
-      enumerable: !0,
-      configurable: !1
-    }), e;
+    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("");
 }
-class N {
+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
@@ -813,6 +771,11 @@ class N {
    * 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.
    *
@@ -825,6 +788,7 @@ class N {
    * @param position - Grid position (branching points only)
    * @param source - Source type (Voltage/Current) or undefined
    *
+   * @param subtype
    * @example
    * ```typescript
    * // Pin node (internal to Circuit)
@@ -846,8 +810,8 @@ class N {
    * );
    * ```
    */
-  constructor(t, e, i, n, s = void 0) {
-    this.id = T(), this.type = t, this.component = e, this.pinLabel = i, this.position = n, this.wires = /* @__PURE__ */ new Set(), this.source = s;
+  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.
@@ -945,7 +909,8 @@ class N {
     const t = {
       id: this.id,
       type: this.type,
-      source: this.source || null
+      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;
   }
@@ -968,7 +933,14 @@ class N {
    * ```
    */
   static fromJSON(t) {
-    const e = t.position ? C.fromJSON(t.position) : void 0, i = new N(t.type, t.component, t.pinLabel, e, t.source);
+    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,
@@ -977,207 +949,289 @@ class N {
     }), i;
   }
 }
-class b {
+class E {
   /**
-   * Current simulation step number (starts at 0).
+   * Unique identifier for this component.
    * @readonly
    */
-  tick;
+  id;
   /**
-   * Electrical state for each ENode (component pins and branching points).
-   * Key: ENode UUID, Value: NodeElectricalState
+   * Component type (Battery, Switch, LED, etc.).
    * @readonly
    */
-  nodeStates;
+  type;
   /**
-   * Electrical state for each Wire connecting ENodes.
-   * Key: Wire UUID, Value: NodeElectricalState
+   * Position on the 2D discrete grid.
    * @readonly
    */
-  wireStates;
+  position;
   /**
-   * Component-specific state for each component.
-   * Key: Component UUID, Value: ComponentState subclass
+   * Orientation angle in degrees.
    * @readonly
    */
-  componentStates;
+  rotation;
   /**
-   * Create a new simulation state snapshot.
+   * Array of pin ENode UUIDs.
+   * Pin order is significant (index 0 is first pin, etc.).
+   * @readonly
+   */
+  pins;
+  /**
+   * 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 IComponentTypeMetadata for details.
    *
-   * @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;
-  }
+  config;
   /**
-   * Create a deep copy of this state for historical storage.
+   * allow to flag a component as non editable (feature to implement)
+   */
+  editable;
+  /**
+   * Create a new component.
    *
-   * @returns Cloned SimulationState
+   * **Note**: Typically components are created via `Circuit.addComponent()`
+   * which handles pin ENode creation automatically. This constructor is used
+   * internally by Circuit.
+   *
+   * @param type - Component type (Battery, Switch, LED, etc.)
+   * @param position - Grid position (integer x, y)
+   * @param rotation - Orientation angle (integer degrees)
+   * @param pins - Array of pin ENode UUIDs
+   *
+   * @param editable
+   * @example
+   * ```typescript
+   * // Usually created via Circuit:
+   * const component = circuit.addComponent(
+   *   new Position(10, 20),
+   *   new Rotation(90),
+   *   ComponentType.Battery
+   * );
+   *
+   * // Direct construction (for deserialization):
+   * const component = new Component(
+   *   ComponentType.Battery,
+   *   new Position(10, 20),
+   *   new Rotation(90),
+   *   ['pin-id-1', 'pin-id-2']
+   * );
+   * ```
    */
-  clone() {
-    const t = new b(this.tick), e = /* @__PURE__ */ new Map();
-    for (const [s, a] of this.nodeStates.entries())
-      e.set(s, { ...a });
-    const i = /* @__PURE__ */ new Map();
-    for (const [s, a] of this.wireStates.entries())
-      i.set(s, { ...a });
-    const n = /* @__PURE__ */ new Map();
-    for (const [s, a] of this.componentStates.entries())
-      n.set(
-        s,
-        Object.assign(Object.create(Object.getPrototypeOf(a)), a)
+  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(a)].join(", ")}`
       );
-    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;
+    }
+    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 i = I[this.type].pins.keys();
+    return Array.from(i)[e] || void 0;
+  }
+  setAllParameters(t) {
+    this.config = new Map(t);
+  }
+  setParameter(t, e) {
+    this.config.set(t, e);
   }
-}
-class z {
-  currentState;
-  history;
-  historyEnabled;
-  historyLimit;
-  historyWriteIndex;
   /**
-   * Create a new state controllerType.
+   * Update the component's position.
    *
-   * @param enableHistory - Whether to store state history (default: false)
-   * @param historyLimit - Maximum number of historical states to keep (default: 1000)
+   * @param newPosition - The new position for the component
+   *
+   * @example
+   * ```typescript
+   * const component = circuit.getComponent(componentId);
+   * component.setPosition(new Position(15, 25));
+   * ```
    */
-  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;
+  setPosition(t) {
+    Object.defineProperty(this, "position", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
   }
   /**
-   * Get the current simulation state.
+   * Update the component's rotation.
    *
-   * @returns Current state (mutable for simulation controller use)
+   * @param newRotation - The new rotation for the component
+   *
+   * @example
+   * ```typescript
+   * const component = circuit.getComponent(componentId);
+   * component.setRotation(new Rotation(90));
+   * ```
    */
-  getCurrentState() {
-    return this.currentState;
+  setRotation(t) {
+    Object.defineProperty(this, "rotation", {
+      value: t,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
   }
   /**
-   * Get current tick number.
+   * Serialize component to JSON.
    *
-   * @returns Current simulation tick
+   * @returns Plain object representation
+   *
+   * @example
+   * ```typescript
+   * const json = component.toJSON();
+   * console.log(json);
+   * // {
+   * //   id: "550e8400-...",
+   * //   type: "battery",
+   * //   position: { x: 10, y: 20 },
+   * //   rotation: 90,
+   * //   pins: ['pin-uuid-1', 'pin-uuid-2']
+   * // }
+   * ```
    */
-  getCurrentTick() {
-    return this.currentState.tick;
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      position: this.position.toJSON(),
+      rotation: this.rotation.toJSON(),
+      pins: [...this.pins],
+      config: Object.fromEntries(this.config),
+      editable: this.editable
+    };
   }
   /**
-   * Advance to next tick, optionally saving current state to history.
-   * Creates a new SimulationState for the next tick.
+   * Deserialize component from JSON.
+   *
+   * @param json - Component data
+   * @returns Component instance
    *
-   * @returns New current state for the next tick
    */
-  advanceToNextTick() {
-    const t = this.currentState.tick + 1;
-    return this.historyEnabled && this.saveToHistory(this.currentState.clone()), this.currentState.tick = t, this.currentState;
+  static fromJSON(t) {
+    const e = new E(
+      t.type,
+      T.fromJSON(t.position),
+      C.fromJSON(t.rotation),
+      t.pins,
+      t.editable
+    );
+    return e.config = new Map(Object.entries(t.config)), Object.defineProperty(e, "id", {
+      value: t.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), e;
   }
+}
+const F = {
   /**
-   * 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
+   * Minimum simulation speed in ticks per second
    */
-  getStateAtTick(t) {
-    if (this.historyEnabled)
-      return this.history.find((e) => e.tick === t);
-  }
+  MIN_TPS: 1,
   /**
-   * Get all available historical states.
-   * Returns empty array if history is disabled.
-   *
-   * @returns Array of historical states, sorted by tick (oldest first)
+   * Maximum simulation speed in ticks per second
    */
-  getHistory() {
-    return this.historyEnabled ? [...this.history].sort((t, e) => t.tick - e.tick) : [];
-  }
+  MAX_TPS: 50,
   /**
-   * Get the oldest tick number available in history.
-   *
-   * @returns Oldest tick number, or undefined if no history
+   * Default simulation speed in ticks per second
    */
-  getOldestTick() {
-    if (!(!this.historyEnabled || this.history.length === 0))
-      return Math.min(...this.history.map((t) => t.tick));
-  }
+  DEFAULT_TPS: 3,
   /**
-   * Get the newest tick number in history (not including current tick).
-   *
-   * @returns Newest historical tick, or undefined if no history
+   * Default tick interval in milliseconds (1000 / DEFAULT_TPS)
    */
-  getNewestHistoricalTick() {
-    if (!(!this.historyEnabled || this.history.length === 0))
-      return Math.max(...this.history.map((t) => t.tick));
-  }
+  DEFAULT_INTERVAL_MS: 500
+}, $ = {
   /**
-   * Clear all history.
+   * Default transitionSpan for relays and transistors in ticks (instant transition)
    */
-  clearHistory() {
-    this.history = [], this.historyWriteIndex = 0;
-  }
+  TRANSITION_SPAN_TICKS: 1,
   /**
-   * Reset to tick 0, clearing current state and all history.
+   * Default transitionUserSpan for switches in milliseconds
    */
-  reset() {
-    this.currentState = new b(0), this.clearHistory();
-  }
+  TRANSITION_USER_SPAN_MS: 200
+};
+class w {
   /**
-   * Check if history tracking is enabled.
-   *
-   * @returns True if history is enabled
+   * Current simulation step number (starts at 0).
+   * @readonly
    */
-  isHistoryEnabled() {
-    return this.historyEnabled;
-  }
+  tick;
   /**
-   * Get the configured history limit.
-   *
-   * @returns Maximum number of historical states
+   * Electrical state for each ENode (component pins and branching points).
+   * Key: ENode UUID, Value: INodeElectricalState
+   * @readonly
    */
-  getHistoryLimit() {
-    return this.historyLimit;
-  }
+  nodeStates;
   /**
-   * Get current history size.
+   * Electrical state for each Wire connecting ENodes.
+   * Key: Wire UUID, Value: INodeElectricalState
+   * @readonly
+   */
+  wireStates;
+  /**
+   * Component-specific state for each component.
+   * Key: Component UUID, Value: ComponentState subclass
+   * @readonly
+   */
+  componentStates;
+  /**
+   * 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 L {
+class D {
   heap;
   /**
    * Create a new empty event queue.
@@ -1228,6 +1282,17 @@ class L {
   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.
    *
@@ -1236,6 +1301,10 @@ class L {
   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);
@@ -1249,9 +1318,9 @@ class L {
     const e = this.heap.length;
     for (; ; ) {
       const i = 2 * t + 1, n = 2 * t + 2;
-      let s = t;
-      if (i < e && this.heap[i].readyAtTick < this.heap[s].readyAtTick && (s = i), n < e && this.heap[n].readyAtTick < this.heap[s].readyAtTick && (s = n), s !== t)
-        [this.heap[t], this.heap[s]] = [this.heap[s], this.heap[t]], t = s;
+      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;
     }
@@ -1263,7 +1332,7 @@ class L {
     return this.heap.length > 0 && e && (this.heap[0] = e, this.bubbleDown(0)), t;
   }
 }
-class R {
+class P {
   dirtyComponents;
   dirtyWires;
   dirtyEnodes;
@@ -1371,34 +1440,134 @@ class R {
     return this.dirtyEnodes.size;
   }
 }
-const $ = {
+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
-}, J = {
+  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
-};
-class U {
+  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;
   eventQueue;
@@ -1414,8 +1583,8 @@ class U {
    */
   constructor(t, e, i = {}) {
     this.circuit = t, this.behaviorRegistry = e;
-    const n = i.enableHistory ?? !1, s = i.historyLimit ?? 1e3;
-    this.stateManager = new z(n, s), this.eventQueue = new L(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new R();
+    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) {
@@ -1431,8 +1600,8 @@ class U {
   tick() {
     const t = this.eventQueue.size(), e = this.stateManager.getCurrentTick(), i = this.applyReadyEvents(e + 1), n = this.updateState(e + 1);
     n.firedEventCount = i.length;
-    const s = this.processCommands();
-    n.processedCommandCount = s.length, n.scheduledEventCount = this.eventQueue.size() + n.firedEventCount - t;
+    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 n.componentUpdateCount = this.dirtyTracker.getDirtyComponentCount(), this.stateManager.advanceToNextTick(), n.endTick = this.stateManager.getCurrentTick(), n;
@@ -1441,7 +1610,7 @@ class U {
    * 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)
@@ -1537,7 +1706,7 @@ class U {
    * 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 = [];
@@ -1547,6 +1716,7 @@ class U {
         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(n.id);
@@ -1581,70 +1751,70 @@ class U {
    */
   initializeState() {
     const t = this.stateManager.getCurrentState();
-    for (const o of this.circuit.getAllComponents()) {
-      if (o.pins.length < 1) continue;
-      const h = this.behaviorRegistry.get(o.type);
-      if (!h)
+    for (const s of this.circuit.getAllComponents()) {
+      if (s.pins.length < 1) continue;
+      const u = this.behaviorRegistry.get(s.type);
+      if (!u)
         continue;
-      const u = h.createInitialState(o);
-      t.componentStates.set(o.id, u), this.dirtyTracker.markComponentDirty(o.id);
+      const d = u.createInitialState(s);
+      t.componentStates.set(s.id, d), this.dirtyTracker.markComponentDirty(s.id);
     }
-    for (const o of this.circuit.getAllENodes())
-      t.nodeStates.set(o.id, {
-        hasVoltage: o.source === v.Voltage,
-        hasCurrent: o.source === v.Current,
-        locked: !!o.source
+    for (const s of this.circuit.getAllENodes())
+      t.nodeStates.set(s.id, {
+        hasVoltage: s.source === v.Voltage,
+        hasCurrent: s.source === v.Current,
+        locked: !!s.source
       });
-    for (const o of this.circuit.getAllWires())
-      t.wireStates.set(o.id, {
+    for (const s of this.circuit.getAllWires())
+      t.wireStates.set(s.id, {
         hasVoltage: !1,
         hasCurrent: !1,
         locked: !1
       });
     const e = this.circuit.getAllComponents(), i = /* @__PURE__ */ new Map();
-    for (const o of e) {
-      const h = this.getInitializationOrder(o.config), u = i.get(h) ?? [];
-      u.push(o), i.set(h, u);
+    for (const s of e) {
+      const u = this.getInitializationOrder(s.config), d = i.get(u) ?? [];
+      d.push(s), i.set(u, d);
     }
-    const n = Array.from(i.keys()).sort((o, h) => o - h);
-    for (const o of n)
-      i.get(o).sort((u, p) => u.id.localeCompare(p.id));
-    let s = !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 (; s && a < c; ) {
-      s = !1, a++;
-      for (const o of n) {
-        const h = i.get(o);
-        for (const u of h) {
-          const p = this.behaviorRegistry.get(u.type);
-          if (!p) continue;
-          const g = t.componentStates.get(u.id);
+    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;
           this.propagateConductivity();
-          const m = p.onPinsChange(
-            u,
+          const b = l.onPinsChange(
+            d,
             g,
             t.nodeStates,
             0
           );
-          m.hasChanged && (s = !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 = p.onEventFiring(u, g, y);
-            d.hasChanged && (s = !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((o) => o.id)])
-    ), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((o) => o.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((o) => o.id)])), l;
+      /* @__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)])), h;
   }
   /**
    * Core method that orchestrates nodes, wires and components state updates
@@ -1652,24 +1822,24 @@ class U {
    * @param targetTick - Tick at which to perform the update
    */
   updateState(t) {
-    const e = this.stateManager.getCurrentState(), { updatedNodes: i, updatedWires: n } = this.propagateConductivity(), s = this.circuit.getComponentsOfPins(i), a = /* @__PURE__ */ new Set();
-    let c = 0, l = Array.from(s);
-    t === 0 && (l = l.sort((o, h) => {
-      const u = this.circuit.getComponent(o), p = this.circuit.getComponent(h), g = this.getInitializationOrder(u.config), m = this.getInitializationOrder(p.config);
-      return g !== m ? g - m : o.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 o of l) {
-      const h = this.circuit.getComponent(o), 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 p = u.onPinsChange(
-        h,
-        e.componentStates.get(o),
+      const l = d.onPinsChange(
+        u,
+        e.componentStates.get(s),
         e.nodeStates,
         t
       );
-      p.hasChanged && a.add(o);
-      for (const g of p.scheduledEvents)
+      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(i), this.dirtyTracker.setDirtyWires(n), {
@@ -1691,33 +1861,33 @@ class U {
    */
   propagateConductivity() {
     const t = this.stateManager.getCurrentState(), e = (c) => {
-      const l = /* @__PURE__ */ new Set(), o = /* @__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)
-      ]), p = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((d) => d.id)]), { nodes: g, 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 == v.Voltage ? "hasVoltage" : "hasCurrent";
-      for (const d of g) {
-        const f = t.nodeStates.get(d);
-        f && !f.locked && (f[y] || (f[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 f = t.nodeStates.get(d);
-        f && !f.locked && f[y] && (f[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 f = t.wireStates.get(d);
-        f && (f[y] || (f[y] = !0, o.add(d)), p.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 p) {
-        const f = t.wireStates.get(d);
-        f && f[y] && (f[y] = !1, o.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: o };
-    }, { updatedNodes: i, updatedWires: n } = e(v.Voltage), { updatedNodes: s, updatedWires: a } = e(v.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([...i, ...s]),
+      updatedNodes: /* @__PURE__ */ new Set([...i, ...r]),
       updatedWires: /* @__PURE__ */ new Set([...n, ...a])
     };
   }
@@ -1730,34 +1900,34 @@ class U {
    * @param componentStates
    */
   computeReachability(t, e, i) {
-    const n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), a = [];
+    const n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), a = [];
     for (const c of e)
       a.push(c), n.add(c);
     for (; a.length > 0; ) {
       const c = a.shift();
-      for (const o of this.circuit.getWiresByNode(c)) {
-        const h = o.node1 === c ? o.node2 : o.node1;
-        n.has(h) || (n.add(h), a.push(h)), s.has(o.id) || s.add(o.id);
+      for (const s of this.circuit.getWiresByNode(c)) {
+        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 === S.Pin) {
-        const o = this.circuit.getComponent(l.component), h = this.behaviorRegistry.get(o.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 = i.get(o.id);
-        for (const p of o.pins) {
-          if (p === c || n.has(p)) continue;
-          h.allowConductivity(
-            o,
-            u,
+        const d = i.get(s.id);
+        for (const l of s.pins) {
+          if (l === c || n.has(l)) continue;
+          u.allowConductivity(
+            s,
+            d,
             t,
             c,
-            p
-          ) && (n.add(p), a.push(p));
+            l
+          ) && (n.add(l), a.push(l));
         }
       }
     }
-    return { nodes: n, wires: s };
+    return { nodes: n, wires: r };
   }
   /**
    * Fire ready events and update current state accordingly
@@ -1770,40 +1940,42 @@ class U {
    */
   applyReadyEvents(t) {
     const e = this.stateManager.getCurrentState(), i = this.eventQueue.getReadyEvents(t), n = [];
-    for (const s of i) {
-      const a = this.circuit.getComponent(s.targetId), c = this.behaviorRegistry.get(a.type);
+    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), o = c.onEventFiring(a, l, s);
-      for (const h of o.scheduledEvents)
-        this.eventQueue.schedule(h);
-      n.push(o);
+      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 n;
   }
 }
 export {
+  W as A,
   M as C,
-  R as D,
+  U as D,
   v as E,
-  C as P,
-  k as R,
-  b as S,
-  J as T,
-  E as a,
-  O as b,
-  I as c,
-  S as d,
-  T as e,
-  G as f,
-  x as g,
-  w as h,
-  A as i,
-  N as j,
-  U as k,
-  z as l,
-  $ as m,
-  L as n,
-  W as s
+  T as P,
+  C as R,
+  F as S,
+  $ as T,
+  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-DEb7JdNf.js.map
+//# sourceMappingURL=CircuitRunner-BQQlhwjD.js.map