simple-circuit-engine 0.0.10 → 0.0.12

package/dist/CircuitRunner-DEb7JdNf.js

@@ -1,1809 +0,0 @@
-class w {
-  /**
-   * Create a new 3D position.
-   *
-   * @param x - X coordinate
-   * @param y - Y coordinate
-   * @param z - Z coordinate
-   */
-  constructor(t, e, i) {
-    this.x = t, this.y = e, this.z = i;
-  }
-  /**
-   * Check if this position equals another position.
-   *
-   * @param other - Position to compare with
-   * @returns true if x,y and z coordinates are equal
-   *
-   * @example
-   * ```typescript
-   * const p1 = new Position(10, 20, 40);
-   * const p2 = new Position(10, 20, 40);
-   * const p3 = new Position(15, 20, 40);
-   *
-   * console.log(p1.equals(p2)); // true
-   * console.log(p1.equals(p3)); // false
-   * ```
-   */
-  equals(t) {
-    return this.x === t.x && this.y === t.y && this.z === t.z;
-  }
-  /**
-   * Serialize position to JSON.
-   *
-   * @returns Plain object with x, y and z properties
-   *
-   * @example
-   * ```typescript
-   * const pos = new Position(10, 20, 40);
-   * const json = pos.toJSON();
-   * console.log(json); // { x: 10, y: 20, z: 40 }
-   * ```
-   */
-  toJSON() {
-    return { x: this.x, y: this.y, z: this.z };
-  }
-  /**
-   * Deserialize position from JSON.
-   *
-   * @param json - Plain object with x, y and z properties
-   * @returns Position instance
-   *
-   * @example
-   * ```typescript
-   * const json = { x: 10, y: 20, z: 40 };
-   * const pos = Position.fromJSON(json);
-   * console.log(pos.x); // 10
-   * ```
-   */
-  static fromJSON(t) {
-    return new w(t.x, t.y, t.z);
-  }
-  /**
-   * String representation for debugging.
-   *
-   * @returns String in format "Position(x, y, z)"
-   */
-  toString() {
-    return `Position(${this.x}, ${this.y}, ${this.z})`;
-  }
-}
-class M {
-  /**
-   * Create new camera options.
-   *
-   * @param position - Camera position (default: 0, 15, 15)
-   * @param lookAtPosition - Camera look-at target position (default: 0, 0, 0)
-   * @param fov - Field of view in degrees (default: 75)
-   * @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;
-  }
-  /**
-   * Serialize camera options to JSON.
-   *
-   * @returns Plain object with camera configuration
-   *
-   * @example
-   * ```typescript
-   * const opts = new CameraOptions();
-   * const json = opts.toJSON();
-   * console.log(json);
-   * // {
-   * //   position: { x: 0, y: 15, z: 0 },
-   * //   lookAtPosition: { x: 0, y: 0, z: 0 },
-   * //   fov: 75,
-   * //   near: 0.1,
-   * //   far: 1000
-   * // }
-   * ```
-   */
-  toJSON() {
-    return {
-      position: this.position.toJSON(),
-      lookAtPosition: this.lookAtPosition.toJSON(),
-      fov: this.fov,
-      near: this.near,
-      far: this.far
-    };
-  }
-  /**
-   * Deserialize camera options from JSON.
-   *
-   * @param json - Plain object with camera configuration
-   * @returns CameraOptions instance
-   *
-   * @example
-   * ```typescript
-   * const json = {
-   *   position: { x: 0, y: 20, z: 10 },
-   *   lookAtPosition: { x: 5, y: 0, z: 0 },
-   *   fov: 60,
-   *   near: 0.5,
-   *   far: 2000
-   * };
-   * const opts = CameraOptions.fromJSON(json);
-   * console.log(opts.position.y); // 20
-   * ```
-   */
-  static fromJSON(t) {
-    return new M(
-      w.fromJSON(t.position),
-      w.fromJSON(t.lookAtPosition),
-      t.fov,
-      t.near,
-      t.far
-    );
-  }
-  /**
-   * String representation for debugging.
-   *
-   * @returns String with camera configuration details
-   */
-  toString() {
-    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 {
-  /**
-   * Create a new position on the discrete grid.
-   *
-   * @param x - X coordinate (must be integer)
-   * @param y - Y coordinate (must be integer)
-   * @throws {TypeError} If x or y are not integers
-   */
-  constructor(t, e) {
-    if (this.x = t, this.y = e, !Number.isInteger(t) || !Number.isInteger(e))
-      throw new TypeError(`Position coordinates must be integers (got x=${t}, y=${e})`);
-  }
-  /**
-   * Check if this position equals another position.
-   *
-   * @param other - Position to compare with
-   * @returns true if both x and y coordinates are equal
-   *
-   * @example
-   * ```typescript
-   * const p1 = new Position(10, 20);
-   * const p2 = new Position(10, 20);
-   * const p3 = new Position(15, 20);
-   *
-   * console.log(p1.equals(p2)); // true
-   * console.log(p1.equals(p3)); // false
-   * ```
-   */
-  equals(t) {
-    return this.x === t.x && this.y === t.y;
-  }
-  /**
-   * Serialize position to JSON.
-   *
-   * @returns Plain object with x and y properties
-   *
-   * @example
-   * ```typescript
-   * const pos = new Position(10, 20);
-   * const json = pos.toJSON();
-   * console.log(json); // { x: 10, y: 20 }
-   * ```
-   */
-  toJSON() {
-    return { x: this.x, y: this.y };
-  }
-  /**
-   * Deserialize position from JSON.
-   *
-   * @param json - Plain object with x and y properties
-   * @returns Position instance
-   * @throws {TypeError} If coordinates are not integers
-   *
-   * @example
-   * ```typescript
-   * const json = { x: 10, y: 20 };
-   * const pos = Position.fromJSON(json);
-   * console.log(pos.x); // 10
-   * ```
-   */
-  static fromJSON(t) {
-    return new C(t.x, t.y);
-  }
-  /**
-   * String representation for debugging.
-   *
-   * @returns String in format "Position(x, y)"
-   */
-  toString() {
-    return `Position(${this.x}, ${this.y})`;
-  }
-}
-function G(r, t, e = 1 / 0) {
-  if (r.length === 0)
-    return 0;
-  if (r.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);
-    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);
-  const a = Math.max(
-    0,
-    Math.min(
-      1,
-      ((r.x - t.x) * i + (r.y - t.y) * n) / s
-    )
-  ), c = t.x + a * i, l = t.y + a * n;
-  return Math.sqrt((r.x - c) ** 2 + (r.y - l) ** 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 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 k {
-  /**
-   * Create a new rotation with the specified angle.
-   *
-   * @param angle - Rotation angle in degrees (must be integer)
-   * @throws {TypeError} If angle is not an integer
-   */
-  constructor(t) {
-    if (this.angle = t, !Number.isInteger(t))
-      throw new TypeError(`Rotation angle must be an integer (got ${t})`);
-  }
-  /**
-   * Serialize rotation to JSON.
-   *
-   * @returns The angle value as a number
-   *
-   * @example
-   * ```typescript
-   * const rotation = new Rotation(90);
-   * const json = rotation.toJSON();
-   * console.log(json); // 90
-   * ```
-   */
-  toJSON() {
-    return this.angle;
-  }
-  /**
-   * Deserialize rotation from JSON.
-   *
-   * @param angle - Angle value
-   * @returns Rotation instance
-   * @throws {TypeError} If angle is not an integer
-   *
-   * @example
-   * ```typescript
-   * const rotation = Rotation.fromJSON(90);
-   * console.log(rotation.angle); // 90
-   * ```
-   */
-  static fromJSON(t) {
-    return new k(t);
-  }
-  /**
-   * Check if this rotation equals another rotation.
-   *
-   * @param other - Rotation to compare with
-   * @returns true if angles are equal
-   *
-   * @example
-   * ```typescript
-   * const r1 = new Rotation(90);
-   * const r2 = new Rotation(90);
-   * const r3 = new Rotation(180);
-   *
-   * console.log(r1.equals(r2)); // true
-   * console.log(r1.equals(r3)); // false
-   * ```
-   */
-  equals(t) {
-    return this.angle === t.angle;
-  }
-  /**
-   * String representation for debugging.
-   *
-   * @returns String in format "Rotation(angle°)"
-   */
-  toString() {
-    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(", ")}`
-      );
-    }
-    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;
-  }
-}
-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).
-   * @readonly
-   */
-  tick;
-  /**
-   * Electrical state for each ENode (component pins and branching points).
-   * Key: ENode UUID, Value: NodeElectricalState
-   * @readonly
-   */
-  nodeStates;
-  /**
-   * Electrical state for each Wire connecting ENodes.
-   * Key: Wire UUID, Value: NodeElectricalState
-   * @readonly
-   */
-  wireStates;
-  /**
-   * Component-specific state for each component.
-   * Key: Component UUID, Value: ComponentState subclass
-   * @readonly
-   */
-  componentStates;
-  /**
-   * Create a new simulation state snapshot.
-   *
-   * @param tick - Current simulation step number
-   */
-  constructor(t) {
-    if (t < 0 || !Number.isInteger(t))
-      throw new RangeError(`Tick must be a non-negative integer (got ${t})`);
-    this.tick = t, this.nodeStates = /* @__PURE__ */ new Map(), this.wireStates = /* @__PURE__ */ new Map(), this.componentStates = /* @__PURE__ */ new Map();
-  }
-  setTick(t) {
-    this.tick = t;
-  }
-  /**
-   * Create a deep copy of this state for historical storage.
-   *
-   * @returns Cloned SimulationState
-   */
-  clone() {
-    const t = new b(this.tick), e = /* @__PURE__ */ new Map();
-    for (const [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)
-      );
-    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 z {
-  currentState;
-  history;
-  historyEnabled;
-  historyLimit;
-  historyWriteIndex;
-  /**
-   * Create a new state controllerType.
-   *
-   * @param enableHistory - Whether to store state history (default: false)
-   * @param historyLimit - Maximum number of historical states to keep (default: 1000)
-   */
-  constructor(t = !1, e = 1e3) {
-    if (e < 1)
-      throw new RangeError(`historyLimit must be at least 1 (got ${e})`);
-    this.historyEnabled = t, this.historyLimit = e, this.currentState = new b(0), this.history = [], this.historyWriteIndex = 0;
-  }
-  /**
-   * Get the current simulation state.
-   *
-   * @returns Current state (mutable for simulation controller use)
-   */
-  getCurrentState() {
-    return this.currentState;
-  }
-  /**
-   * Get current tick number.
-   *
-   * @returns Current simulation tick
-   */
-  getCurrentTick() {
-    return this.currentState.tick;
-  }
-  /**
-   * Advance to next tick, optionally saving current state to history.
-   * Creates a new SimulationState for the next tick.
-   *
-   * @returns New current state for the next tick
-   */
-  advanceToNextTick() {
-    const t = this.currentState.tick + 1;
-    return this.historyEnabled && this.saveToHistory(this.currentState.clone()), this.currentState.tick = t, this.currentState;
-  }
-  /**
-   * 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
-   */
-  getStateAtTick(t) {
-    if (this.historyEnabled)
-      return this.history.find((e) => e.tick === t);
-  }
-  /**
-   * Get all available historical states.
-   * Returns empty array if history is disabled.
-   *
-   * @returns Array of historical states, sorted by tick (oldest first)
-   */
-  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 b(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 L {
-  heap;
-  /**
-   * Create a new empty event queue.
-   */
-  constructor() {
-    this.heap = [];
-  }
-  /**
-   * Schedule a future event.
-   * Inserted with O(log N) complexity using heap operations.
-   *
-   * @param event - Event to schedule
-   */
-  schedule(t) {
-    if (t.readyAtTick < t.scheduledAtTick)
-      throw new RangeError(
-        `readyAtTick (${t.readyAtTick}) cannot be before scheduledAtTick (${t.scheduledAtTick})`
-      );
-    this.heap.push(t), this.bubbleUp(this.heap.length - 1);
-  }
-  /**
-   * Get all events ready to fire at or before current tick.
-   * Returns events in FIFO order for same readyAtTick.
-   * Removes returned events from the queue.
-   *
-   * @param currentTick - Current simulation tick
-   * @returns Array of ready events (removed from queue)
-   */
-  getReadyEvents(t) {
-    const e = [];
-    for (; this.heap.length > 0 && this.heap[0].readyAtTick <= t; ) {
-      const i = this.extractMin();
-      i && e.push(i);
-    }
-    return e.sort((i, n) => i.readyAtTick === n.readyAtTick ? i.scheduledAtTick - n.scheduledAtTick : i.readyAtTick - n.readyAtTick), e;
-  }
-  /**
-   * Check if any events are pending.
-   *
-   * @returns True if queue contains events
-   */
-  hasEvents() {
-    return this.heap.length > 0;
-  }
-  /**
-   * Clear all pending events.
-   */
-  clear() {
-    this.heap = [];
-  }
-  /**
-   * Get number of pending events.
-   *
-   * @returns Event count
-   */
-  size() {
-    return this.heap.length;
-  }
-  bubbleUp(t) {
-    for (; t > 0; ) {
-      const e = Math.floor((t - 1) / 2);
-      if (this.heap[t].readyAtTick < this.heap[e].readyAtTick)
-        [this.heap[t], this.heap[e]] = [this.heap[e], this.heap[t]], t = e;
-      else
-        break;
-    }
-  }
-  bubbleDown(t) {
-    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;
-      else
-        break;
-    }
-  }
-  extractMin() {
-    if (this.heap.length === 0)
-      return;
-    const t = this.heap[0], e = this.heap.pop();
-    return this.heap.length > 0 && e && (this.heap[0] = e, this.bubbleDown(0)), t;
-  }
-}
-class R {
-  dirtyComponents;
-  dirtyWires;
-  dirtyEnodes;
-  /**
-   * Create a new dirty tracker with no marked elements.
-   */
-  constructor() {
-    this.dirtyComponents = /* @__PURE__ */ new Set(), this.dirtyWires = /* @__PURE__ */ new Set(), this.dirtyEnodes = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Mark a component as having changed state this tick.
-   *
-   * @param componentId - UUID of the component
-   */
-  markComponentDirty(t) {
-    this.dirtyComponents.add(t);
-  }
-  /**
-   * Mark a wire as having changed electrical state this tick.
-   *
-   * @param wireId - UUID of the wire
-   */
-  markWireDirty(t) {
-    this.dirtyWires.add(t);
-  }
-  /**
-   * Mark an ENode as having changed electrical state this tick.
-   *
-   * @param enodeId - UUID of the ENode
-   */
-  markEnodeDirty(t) {
-    this.dirtyEnodes.add(t);
-  }
-  /**
-   * Set the entire set of dirty components. Should be only used at CircuitRunner initialization.
-   * @param componentIds
-   */
-  setDirtyComponents(t) {
-    this.dirtyComponents = new Set(t);
-  }
-  /**
-   * Set the entire set of dirty components. Should be only used at CircuitRunner initialization.
-   * @param enodeIds
-   */
-  setDirtyEnodes(t) {
-    this.dirtyEnodes = new Set(t);
-  }
-  /**
-   * Set the entire set of dirty components. Should be only used at CircuitRunner initialization.
-   * @param wireIds
-   */
-  setDirtyWires(t) {
-    this.dirtyWires = new Set(t);
-  }
-  /**
-   * Get all dirty elements and clear the tracker.
-   * This is typically called at the end of a tick to collect changes.
-   *
-   * @returns Object containing sets of dirty component/wire/enode UUIDs
-   */
-  getDirtyElements() {
-    const t = {
-      components: new Set(this.dirtyComponents),
-      wires: new Set(this.dirtyWires),
-      enodes: new Set(this.dirtyEnodes)
-    };
-    return this.clear(), t;
-  }
-  /**
-   * Check if any elements are marked dirty.
-   *
-   * @returns True if at least one element is dirty
-   */
-  hasDirtyElements() {
-    return this.dirtyComponents.size > 0 || this.dirtyWires.size > 0 || this.dirtyEnodes.size > 0;
-  }
-  /**
-   * Clear all dirty markers without returning them.
-   */
-  clear() {
-    this.dirtyComponents.clear(), this.dirtyWires.clear(), this.dirtyEnodes.clear();
-  }
-  /**
-   * Get current count of dirty components (for debugging/metrics).
-   *
-   * @returns Number of dirty components
-   */
-  getDirtyComponentCount() {
-    return this.dirtyComponents.size;
-  }
-  /**
-   * Get current count of dirty wires (for debugging/metrics).
-   *
-   * @returns Number of dirty wires
-   */
-  getDirtyWireCount() {
-    return this.dirtyWires.size;
-  }
-  /**
-   * Get current count of dirty enodes (for debugging/metrics).
-   *
-   * @returns Number of dirty enodes
-   */
-  getDirtyEnodeCount() {
-    return this.dirtyEnodes.size;
-  }
-}
-const $ = {
-  /**
-   * Minimum simulation speed in ticks per second
-   */
-  MIN_TPS: 1,
-  /**
-   * Maximum simulation speed in ticks per second
-   */
-  MAX_TPS: 50,
-  /**
-   * Default simulation speed in ticks per second
-   */
-  DEFAULT_TPS: 3,
-  /**
-   * Default tick interval in milliseconds (1000 / DEFAULT_TPS)
-   */
-  DEFAULT_INTERVAL_MS: 500
-}, J = {
-  /**
-   * Default transitionSpan for relays and transistors in ticks (instant transition)
-   */
-  TRANSITION_SPAN_TICKS: 1,
-  /**
-   * Default transitionUserSpan for switches in milliseconds
-   */
-  TRANSITION_USER_SPAN_MS: 200
-};
-class U {
-  circuit;
-  stateManager;
-  eventQueue;
-  commands;
-  dirtyTracker;
-  behaviorRegistry;
-  /**
-   * Create a new circuit simulation runner.
-   *
-   * @param circuit - The circuit topology to simulate
-   * @param behaviorRegistry - Registry of component behaviors
-   * @param options - Simulation options (history settings)
-   */
-  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();
-    try {
-      this.initializeState();
-    } catch (a) {
-      throw console.error("Error during CircuitRunner initialization:", a), a;
-    }
-  }
-  /**
-   * Execute one simulation tick.
-   * Process scheduled events, update state (electrical propagation), process user commands and advance tick.
-   *
-   * @returns the result of the tick execution
-   */
-  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;
-    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;
-  }
-  /**
-   * Execute multiple simulation ticks.
-   *
-   * @param count - Number of ticks to execute
-   * @returns an array of RunnerResult for each tick executed
-   */
-  tickN(t) {
-    if (t < 1)
-      throw new RangeError(`Tick count must be at least 1 (got ${t})`);
-    const e = [];
-    for (let i = 0; i < t; i++)
-      e.push(this.tick());
-    return e;
-  }
-  /**
-   * Reset simulation to tick 0.
-   * Clears all state, history, and scheduled events.
-   */
-  reset() {
-    this.stateManager.reset(), this.eventQueue.clear(), this.dirtyTracker.clear(), this.initializeState();
-  }
-  /**
-   * Get current simulation tick number.
-   *
-   * @returns Current tick
-   */
-  getCurrentTick() {
-    return this.stateManager.getCurrentTick();
-  }
-  /**
-   * Get current simulation state snapshot.
-   *
-   * @returns Current state (readonly)
-   */
-  getCurrentState() {
-    return this.stateManager.getCurrentState();
-  }
-  /**
-   * Get electrical state of a specific ENode.
-   *
-   * @param enodeId - UUID of the ENode
-   * @returns Electrical state, or undefined if not found
-   */
-  getEnodeState(t) {
-    return this.stateManager.getCurrentState().nodeStates.get(t);
-  }
-  /**
-   * Get electrical state of a specific Wire.
-   *
-   * @param wireId - UUID of the Wire
-   * @returns Electrical state, or undefined if not found
-   */
-  getWireState(t) {
-    return this.stateManager.getCurrentState().wireStates.get(t);
-  }
-  /**
-   * Get component state for a specific component.
-   *
-   * @param componentId - UUID of the component
-   * @returns Component state, or undefined if not found
-   */
-  getComponentState(t) {
-    return this.stateManager.getCurrentState().componentStates.get(t);
-  }
-  /**
-   * Get historical state at a specific tick.
-   * Only works if history is enabled.
-   *
-   * @param tick - Tick number to retrieve
-   * @returns Historical state, or undefined if not available
-   */
-  getStateAtTick(t) {
-    return this.stateManager.getStateAtTick(t);
-  }
-  /**
-   * Check if a component is registered in behavior registry.
-   *
-   * @param componentType - Component type to check
-   * @returns True if behavior is registered
-   */
-  hasBehavior(t) {
-    return this.behaviorRegistry.has(t);
-  }
-  /**
-   * Submit a user command to execute at the next tick.
-   * only one command per component per tick is allowed.
-   * Subsequent commands for the same component at this tick will be discarded.
-   *
-   * @param command - User command to submit
-   */
-  submitCommand(t) {
-    if (!this.circuit.hasComponent(t.targetId))
-      throw Error(`Cannot submit command for unknown component ID '${t.targetId}'`);
-    return this.commands.has(t.targetId) ? !1 : (t.scheduledAtTick = this.getCurrentTick(), this.commands.set(t.targetId, t), !0);
-  }
-  /**
-   * Process all scheduled user commands.
-   * Mark changed components as Dirty and enqueue consequent scheduled events
-   * Finally clears command queue after processing.
-   *
-   * @returns Array of BehaviorResult for each processed command
-   */
-  processCommands() {
-    const t = this.stateManager.getCurrentState(), e = [];
-    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(n.id);
-    }
-    return this.commands.clear(), e;
-  }
-  /**
-   * Helper function to extract initializationOrder from component config.
-   * Returns numeric order value, with empty string or null defaulting to 0.
-   *
-   * @param config - Component configuration map
-   * @returns Order value (lower = processed first)
-   */
-  getInitializationOrder(t) {
-    const e = t.get("initializationOrder");
-    if (!e || e === "") return 0;
-    const i = parseInt(e, 10);
-    return isNaN(i) ? 0 : i;
-  }
-  /**
-   * Initialize simulation state for all components.
-   * Called on construction and reset.
-   *
-   * Uses order-based initialization to resolve feedback loops:
-   * 1. Components are grouped by initializationOrder (higher = processed LAST)
-   * 2. Within each group, components are sorted by UUID (ascending) for determinism
-   * 3. Conductivity is propagated after each component
-   *
-   * In feedback circuits, the component processed LAST "wins" because earlier
-   * components react to the initial symmetric state and open, while later
-   * components see the updated (asymmetric) state and stay closed.
-   */
-  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)
-        continue;
-      const u = h.createInitialState(o);
-      t.componentStates.set(o.id, u), this.dirtyTracker.markComponentDirty(o.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 o of this.circuit.getAllWires())
-      t.wireStates.set(o.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);
-    }
-    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 (; 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);
-          if (!g) continue;
-          this.propagateConductivity();
-          const m = p.onPinsChange(
-            u,
-            g,
-            t.nodeStates,
-            0
-          );
-          m.hasChanged && (s = !0, t.componentStates.set(
-            u.id,
-            m.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
-            ));
-          }
-        }
-      }
-    }
-    const l = 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;
-  }
-  /**
-   * Core method that orchestrates nodes, wires and components state updates
-   * enqueue resulting events and update dirty tracker accordingly
-   * @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);
-    }));
-    for (const o of l) {
-      const h = this.circuit.getComponent(o), u = this.behaviorRegistry.get(h.type);
-      if (!u)
-        continue;
-      const p = u.onPinsChange(
-        h,
-        e.componentStates.get(o),
-        e.nodeStates,
-        t
-      );
-      p.hasChanged && a.add(o);
-      for (const g of p.scheduledEvents)
-        this.eventQueue.schedule(g), c++;
-    }
-    return this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(i), this.dirtyTracker.setDirtyWires(n), {
-      startTick: this.getCurrentTick(),
-      endTick: this.getCurrentTick(),
-      componentUpdateCount: a.size,
-      nodeUpdateCount: i.size,
-      wireUpdateCount: n.size,
-      processedCommandCount: 0,
-      scheduledEventCount: c,
-      firedEventCount: 0
-    };
-  }
-  /**
-   * runs BFS (Breadth First Search) on voltage and current conductivity
-   * to propagate voltage/current conductivity
-   * and update enodes/wires electrical states throughout the circuit
-   * update is performed in place and updated nodes and wires returned
-   */
-  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(
-        c,
-        h,
-        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));
-      }
-      for (const d of u) {
-        const f = t.nodeStates.get(d);
-        f && !f.locked && f[y] && (f[y] = !1, l.add(d));
-      }
-      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 d of p) {
-        const f = t.wireStates.get(d);
-        f && f[y] && (f[y] = !1, o.add(d));
-      }
-      return { updatedNodes: l, updatedWires: o };
-    }, { updatedNodes: i, updatedWires: n } = e(v.Voltage), { updatedNodes: s, updatedWires: a } = e(v.Current);
-    return {
-      updatedNodes: /* @__PURE__ */ new Set([...i, ...s]),
-      updatedWires: /* @__PURE__ */ new Set([...n, ...a])
-    };
-  }
-  /**
-   * given a conductivity conductivityType and a set of seed nodes, compute all reachable nodes and wires
-   * depends on componentStates to determine if conductivity is allowed through components
-   * this method doesn't mutate any state, it's a pure function
-   * @param conductivityType
-   * @param seeds
-   * @param componentStates
-   */
-  computeReachability(t, e, i) {
-    const n = /* @__PURE__ */ new Set(), s = /* @__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);
-      }
-      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)
-          continue;
-        const u = i.get(o.id);
-        for (const p of o.pins) {
-          if (p === c || n.has(p)) continue;
-          h.allowConductivity(
-            o,
-            u,
-            t,
-            c,
-            p
-          ) && (n.add(p), a.push(p));
-        }
-      }
-    }
-    return { nodes: n, wires: s };
-  }
-  /**
-   * Fire ready events and update current state accordingly
-   * eventual subsequent events are enqueued
-   *
-   * @param targetTick - Tick at which to process events
-   * @param events - Events to apply
-   * @param state - Current simulation state
-   * @param targetTick - Target tick for event processing
-   */
-  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);
-      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);
-    }
-    return n;
-  }
-}
-export {
-  M as C,
-  R 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
-};
-//# sourceMappingURL=CircuitRunner-DEb7JdNf.js.map