simple-circuit-engine 0.0.8 → 0.0.10

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

@@ -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.
@@ -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 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;
   }
   /**
    * Serialize camera options to JSON.
@@ -129,7 +129,7 @@ class k {
    * ```
    */
   static fromJSON(t) {
-    return new k(
+    return new M(
       w.fromJSON(t.position),
       w.fromJSON(t.lookAtPosition),
       t.fov,
@@ -146,8 +146,8 @@ 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 = {
+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",
@@ -164,8 +164,8 @@ const E = {
     id: "battery",
     name: "Battery",
     pins: /* @__PURE__ */ new Map([
-      ["cathode", S.Voltage],
-      ["anode", S.Current]
+      ["cathode", v.Voltage],
+      ["anode", v.Current]
     ]),
     config: /* @__PURE__ */ new Map([])
   },
@@ -205,6 +205,19 @@ const E = {
       ["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",
@@ -250,33 +263,149 @@ const E = {
       ["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 z() {
-  return Object.values(T);
+function x() {
+  return Object.values(E);
 }
-function N(n) {
-  return E[n];
+function I(r) {
+  return O[r];
 }
-var M = /* @__PURE__ */ ((n) => (n.Pin = "Pin", n.BranchingPoint = "BranchingPoint", n))(M || {});
-function I() {
+var S = /* @__PURE__ */ ((r) => (r.Pin = "Pin", r.BranchingPoint = "BranchingPoint", r))(S || {});
+function T() {
   if (typeof crypto < "u" && crypto.randomUUID)
     return crypto.randomUUID();
-  const n = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
+  const r = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
   for (const c of t) {
     let l = "";
-    for (let s = 0; s < c; s++) {
+    for (let o = 0; o < c; o++) {
       const h = Math.floor(Math.random() * 16);
-      l += n[h];
+      l += r[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("");
+  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 v {
+class C {
   /**
    * Create a new position on the discrete grid.
    *
@@ -337,7 +466,7 @@ class v {
    * ```
    */
   static fromJSON(t) {
-    return new v(t.x, t.y);
+    return new C(t.x, t.y);
   }
   /**
    * String representation for debugging.
@@ -348,46 +477,46 @@ class v {
     return `Position(${this.x}, ${this.y})`;
   }
 }
-function W(n, t, e = 1 / 0) {
-  if (n.length === 0)
+function G(r, t, e = 1 / 0) {
+  if (r.length === 0)
     return 0;
-  if (n.length === 1)
+  if (r.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 < r.length - 1; n++) {
+    const s = r[n], a = r[n + 1], c = D(t, s, 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 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);
   const a = Math.max(
     0,
     Math.min(
       1,
-      ((n.x - t.x) * r + (n.y - t.y) * i) / o
+      ((r.x - t.x) * i + (r.y - t.y) * n) / s
     )
-  ), 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, l = t.y + a * n;
+  return Math.sqrt((r.x - c) ** 2 + (r.y - l) ** 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 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 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 P(r, t, e, i = 5) {
+  const n = (t.x - r.x) * (e.y - r.y) - (t.y - r.y) * (e.x - r.x);
+  return Math.abs(n) <= i;
 }
-class C {
+class k {
   /**
    * Create a new rotation with the specified angle.
    *
@@ -427,7 +556,7 @@ class C {
    * ```
    */
   static fromJSON(t) {
-    return new C(t);
+    return new k(t);
   }
   /**
    * Check if this rotation equals another rotation.
@@ -522,21 +651,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) {
+    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(o)].join(", ")}`
+        `Duplicate pin names are not allowed: ${[...new Set(s)].join(", ")}`
       );
     }
-    this.pins = i, this.config = new Map(E[t].config);
+    this.pins = n, this.config = new Map(O[t].config);
   }
   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);
@@ -634,8 +763,8 @@ class A {
   static fromJSON(t) {
     const e = new A(
       t.type,
-      v.fromJSON(t.position),
-      C.fromJSON(t.rotation),
+      C.fromJSON(t.position),
+      k.fromJSON(t.rotation),
       t.pins
     );
     return e.config = new Map(Object.entries(t.config)), Object.defineProperty(e, "id", {
@@ -646,6 +775,208 @@ class A {
     }), e;
   }
 }
+class N {
+  /**
+   * 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;
+  /**
+   * 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
+   *
+   * @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, 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;
+  }
+  /**
+   * 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
+    };
+    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 ? C.fromJSON(t.position) : void 0, i = new N(t.type, t.component, t.pinLabel, e, t.source);
+    return Object.defineProperty(i, "id", {
+      value: t.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}
 class b {
   /**
    * Current simulation step number (starts at 0).
@@ -690,15 +1021,15 @@ class b {
    */
   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 });
+    for (const [s, a] of this.nodeStates.entries())
+      e.set(s, { ...a });
     const i = /* @__PURE__ */ new Map();
-    for (const [o, a] of this.componentStates.entries())
-      i.set(
-        o,
+    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)
       );
     return Object.defineProperty(t, "nodeStates", {
@@ -707,19 +1038,19 @@ class b {
       configurable: !1,
       enumerable: !0
     }), Object.defineProperty(t, "wireStates", {
-      value: r,
+      value: i,
       writable: !1,
       configurable: !1,
       enumerable: !0
     }), Object.defineProperty(t, "componentStates", {
-      value: i,
+      value: n,
       writable: !1,
       configurable: !1,
       enumerable: !0
     }), t;
   }
 }
-class R {
+class z {
   currentState;
   history;
   historyEnabled;
@@ -846,7 +1177,7 @@ class R {
     this.history.length < this.historyLimit ? this.history.push(t) : (this.history[this.historyWriteIndex] = t, this.historyWriteIndex = (this.historyWriteIndex + 1) % this.historyLimit);
   }
 }
-class x {
+class L {
   heap;
   /**
    * Create a new empty event queue.
@@ -878,10 +1209,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.
@@ -917,10 +1248,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 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;
       else
         break;
     }
@@ -932,7 +1263,7 @@ class x {
     return this.heap.length > 0 && e && (this.heap[0] = e, this.bubbleDown(0)), t;
   }
 }
-class P {
+class R {
   dirtyComponents;
   dirtyWires;
   dirtyEnodes;
@@ -1040,7 +1371,7 @@ class P {
     return this.dirtyEnodes.size;
   }
 }
-const U = {
+const $ = {
   /**
    * Minimum simulation speed in ticks per second
    */
@@ -1057,7 +1388,7 @@ const U = {
    * Default tick interval in milliseconds (1000 / DEFAULT_TPS)
    */
   DEFAULT_INTERVAL_MS: 500
-}, $ = {
+}, J = {
   /**
    * Default transitionSpan for relays and transistors in ticks (instant transition)
    */
@@ -1067,7 +1398,7 @@ const U = {
    */
   TRANSITION_USER_SPAN_MS: 200
 };
-class J {
+class U {
   circuit;
   stateManager;
   eventQueue;
@@ -1081,10 +1412,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, s = i.historyLimit ?? 1e3;
+    this.stateManager = new z(n, s), this.eventQueue = new L(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new R();
     try {
       this.initializeState();
     } catch (a) {
@@ -1098,13 +1429,13 @@ 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 s = this.processCommands();
+    n.processedCommandCount = s.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.
@@ -1116,7 +1447,7 @@ class J {
     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;
   }
@@ -1210,15 +1541,15 @@ class J {
    */
   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
       );
       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 +1563,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.
@@ -1250,59 +1581,59 @@ class J {
    */
   initializeState() {
     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);
+    for (const o of this.circuit.getAllComponents()) {
+      if (o.pins.length < 1) continue;
+      const h = this.behaviorRegistry.get(o.type);
       if (!h)
         continue;
-      const u = h.createInitialState(s);
-      t.componentStates.set(s.id, u), this.dirtyTracker.markComponentDirty(s.id);
+      const u = h.createInitialState(o);
+      t.componentStates.set(o.id, u), this.dirtyTracker.markComponentDirty(o.id);
     }
-    for (const s of this.circuit.getAllENodes())
-      t.nodeStates.set(s.id, {
-        hasVoltage: s.source === S.Voltage,
-        hasCurrent: s.source === S.Current,
-        locked: !!s.source
+    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.getAllWires())
-      t.wireStates.set(s.id, {
+    for (const o of this.circuit.getAllWires())
+      t.wireStates.set(o.id, {
         hasVoltage: !1,
         hasCurrent: !1,
         locked: !1
       });
-    const e = this.circuit.getAllComponents(), r = /* @__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 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);
     }
-    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((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 c = 100;
-    for (; o && a < c; ) {
-      o = !1, a++;
-      for (const s of i) {
-        const h = r.get(s);
+    for (; s && a < c; ) {
+      s = !1, a++;
+      for (const o of n) {
+        const h = i.get(o);
         for (const u of h) {
-          const g = this.behaviorRegistry.get(u.type);
+          const p = this.behaviorRegistry.get(u.type);
+          if (!p) continue;
+          const g = t.componentStates.get(u.id);
           if (!g) continue;
-          const f = t.componentStates.get(u.id);
-          if (!f) continue;
           this.propagateConductivity();
-          const m = g.onPinsChange(
+          const m = p.onPinsChange(
             u,
-            f,
+            g,
             t.nodeStates,
             0
           );
-          m.hasChanged && (o = !0, t.componentStates.set(
+          m.hasChanged && (s = !0, t.componentStates.set(
             u.id,
             m.componentState
           ));
           for (const y of m.scheduledEvents) {
-            const d = g.onEventFiring(u, f, y);
-            d.hasChanged && (o = !0, t.componentStates.set(
+            const d = p.onEventFiring(u, g, y);
+            d.hasChanged && (s = !0, t.componentStates.set(
               u.id,
               d.componentState
             ));
@@ -1312,8 +1643,8 @@ class J {
     }
     const l = 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;
+      /* @__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;
   }
   /**
    * Core method that orchestrates nodes, wires and components state updates
@@ -1321,32 +1652,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(), 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);
     }));
-    for (const s of l) {
-      const h = this.circuit.getComponent(s), u = this.behaviorRegistry.get(h.type);
+    for (const o of l) {
+      const h = this.circuit.getComponent(o), u = this.behaviorRegistry.get(h.type);
       if (!u)
         continue;
-      const g = u.onPinsChange(
+      const p = u.onPinsChange(
         h,
-        e.componentStates.get(s),
+        e.componentStates.get(o),
         e.nodeStates,
         t
       );
-      g.hasChanged && a.add(s);
-      for (const f of g.scheduledEvents)
-        this.eventQueue.schedule(f), c++;
+      p.hasChanged && a.add(o);
+      for (const g of p.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 +1691,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([
+      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)
-      ]), g = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((d) => d.id)]), { nodes: f, wires: m } = this.computeReachability(
+      ]), p = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((d) => d.id)]), { nodes: g, wires: m } = this.computeReachability(
         c,
         h,
         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));
+      ), 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));
       }
       for (const d of u) {
-        const p = t.nodeStates.get(d);
-        p && !p.locked && p[y] && (p[y] = !1, l.add(d));
+        const f = t.nodeStates.get(d);
+        f && !f.locked && f[y] && (f[y] = !1, l.add(d));
       }
       for (const d of m) {
-        const p = t.wireStates.get(d);
-        p && (p[y] || (p[y] = !0, s.add(d)), g.delete(d));
+        const f = t.wireStates.get(d);
+        f && (f[y] || (f[y] = !0, o.add(d)), p.delete(d));
       }
-      for (const d of g) {
-        const p = t.wireStates.get(d);
-        p && p[y] && (p[y] = !1, s.add(d));
+      for (const d of p) {
+        const f = t.wireStates.get(d);
+        f && f[y] && (f[y] = !1, o.add(d));
       }
-      return { updatedNodes: l, updatedWires: s };
-    }, { updatedNodes: r, updatedWires: i } = e(S.Voltage), { updatedNodes: o, updatedWires: a } = e(S.Current);
+      return { updatedNodes: l, updatedWires: o };
+    }, { updatedNodes: i, updatedWires: n } = e(v.Voltage), { updatedNodes: s, updatedWires: a } = e(v.Current);
     return {
-      updatedNodes: /* @__PURE__ */ new Set([...r, ...o]),
-      updatedWires: /* @__PURE__ */ new Set([...i, ...a])
+      updatedNodes: /* @__PURE__ */ new Set([...i, ...s]),
+      updatedWires: /* @__PURE__ */ new Set([...n, ...a])
     };
   }
   /**
@@ -1398,35 +1729,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(), s = /* @__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);
+      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);
       }
       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 (l.type === S.Pin) {
+        const o = this.circuit.getComponent(l.component), h = this.behaviorRegistry.get(o.type);
         if (!h)
           continue;
-        const u = r.get(s.id);
-        for (const g of s.pins) {
-          if (g === c || i.has(g)) continue;
+        const u = i.get(o.id);
+        for (const p of o.pins) {
+          if (p === c || n.has(p)) continue;
           h.allowConductivity(
-            s,
+            o,
             u,
             t,
             c,
-            g
-          ) && (i.add(g), a.push(g));
+            p
+          ) && (n.add(p), a.push(p));
         }
       }
     }
-    return { nodes: i, wires: o };
+    return { nodes: n, wires: s };
   }
   /**
    * Fire ready events and update current state accordingly
@@ -1438,40 +1769,41 @@ 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 s of i) {
+      const a = this.circuit.getComponent(s.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)
+      const l = e.componentStates.get(a.id), o = c.onEventFiring(a, l, s);
+      for (const h of o.scheduledEvents)
         this.eventQueue.schedule(h);
-      i.push(s);
+      n.push(o);
     }
-    return i;
+    return n;
   }
 }
 export {
-  k as C,
-  P as D,
-  S as E,
-  v as P,
-  C as R,
+  M as C,
+  R as D,
+  v as E,
+  C as P,
+  k as R,
   b 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,
+  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,
-  J as j,
-  R as k,
-  U as l,
-  x as m,
-  L as s
+  N as j,
+  U as k,
+  z as l,
+  $ as m,
+  L as n,
+  W as s
 };
-//# sourceMappingURL=CircuitRunner-FXM_s5ll.js.map
+//# sourceMappingURL=CircuitRunner-DEb7JdNf.js.map