simple-circuit-engine 0.0.11 → 0.0.12

package/dist/CircuitRunner-BQQlhwjD.js

@@ -1,1981 +0,0 @@
-class m {
-  /**
-   * 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 m(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 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.
-   *
-   * @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(
-      m.fromJSON(t.position),
-      m.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})`;
-  }
-}
-class T {
-  /**
-   * 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 T(t.x, t.y);
-  }
-  /**
-   * String representation for debugging.
-   *
-   * @returns String in format "Position(x, y)"
-   */
-  toString() {
-    return `Position(${this.x}, ${this.y})`;
-  }
-}
-function R(o, t, e = 1 / 0) {
-  if (o.length === 0)
-    return 0;
-  if (o.length === 1)
-    return 1;
-  let i = 1;
-  for (let n = 0; n < o.length - 1; n++) {
-    const r = o[n], a = o[n + 1], c = N(t, r, a);
-    c < e && (e = c, i = n + 1);
-  }
-  return i;
-}
-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,
-      ((o.x - t.x) * i + (o.y - t.y) * n) / r
-    )
-  ), c = t.x + a * i, h = t.y + a * n;
-  return Math.sqrt((o.x - c) ** 2 + (o.y - h) ** 2);
-}
-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 A(o, t, e, i = 5) {
-  const n = (t.x - o.x) * (e.y - o.y) - (t.y - o.y) * (e.x - o.x);
-  return Math.abs(n) <= i;
-}
-class C {
-  /**
-   * 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 C(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}°)`;
-  }
-}
-function O() {
-  if (typeof crypto < "u" && crypto.randomUUID)
-    return crypto.randomUUID();
-  const o = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
-  for (const c of t) {
-    let h = "";
-    for (let s = 0; s < c; s++) {
-      const u = Math.floor(Math.random() * 16);
-      h += o[u];
-    }
-    e.push(h);
-  }
-  const n = e.join("-").split("");
-  n[14] = "4";
-  const a = parseInt(n[19] ?? "0", 16) & 3 | 8;
-  return n[19] = o[a] ?? "0", n.join("");
-}
-const G = "0.0.11";
-var v = /* @__PURE__ */ ((o) => (o.Voltage = "Voltage", o.Current = "Current", o))(v || {}), S = /* @__PURE__ */ ((o) => (o.Pin = "Pin", o.BranchingPoint = "BranchingPoint", o))(S || {});
-const W = ["CMOS1", "TTL1", "Sandbox"], U = "CMOS1";
-var L = /* @__PURE__ */ ((o) => (o.Cube = "cube", o.Label = "label", o.Battery = "battery", o.Switch = "switch", o.DoubleThrowSwitch = "doubleThrowSwitch", o.Lightbulb = "lightbulb", o.Relay = "relay", o.SmallLED = "smallLED", o.RectangleLED = "rectangleLED", o.Inverter = "inverter", o.NandGate = "nandGate", o.Nand4Gate = "nand4Gate", o.Nand8Gate = "nand8Gate", o.NorGate = "norGate", o.Nor4Gate = "nor4Gate", o.Nor8Gate = "nor8Gate", o.XorGate = "xorGate", o.Xor4Gate = "xor4Gate", o.Xor8Gate = "xor8Gate", o))(L || {});
-const I = {
-  switch: {
-    id: "switch",
-    name: "Switch",
-    pins: /* @__PURE__ */ new Map([
-      ["input", { subtype: "free", sourceType: void 0 }],
-      ["output", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["initialState", "open"],
-      ["size", "1"]
-    ])
-  },
-  doubleThrowSwitch: {
-    id: "doubleThrowSwitch",
-    // SPDT (Single-Pole Double-Throw) Switch
-    name: "DoubleThrowSwitch",
-    pins: /* @__PURE__ */ new Map([
-      ["input1", { subtype: "free", sourceType: void 0 }],
-      ["input2", { subtype: "free", sourceType: void 0 }],
-      ["output", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["initialState", "input1"],
-      ["size", "1"]
-    ])
-  },
-  battery: {
-    id: "battery",
-    name: "Battery",
-    pins: /* @__PURE__ */ new Map([
-      ["cathode", {
-        subtype: "mainVcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["anode", {
-        subtype: "mainGnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([])
-  },
-  lightbulb: {
-    id: "lightbulb",
-    name: "Lightbulb",
-    pins: /* @__PURE__ */ new Map([
-      ["pin1", { subtype: "free", sourceType: void 0 }],
-      ["pin2", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([["size", "1"]])
-  },
-  relay: {
-    id: "relay",
-    name: "Relay",
-    pins: /* @__PURE__ */ new Map([
-      ["cmd_in", { subtype: "free", sourceType: void 0 }],
-      ["cmd_out", { subtype: "free", sourceType: void 0 }],
-      ["power_in", { subtype: "free", sourceType: void 0 }],
-      ["power_out", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["activationLogic", "positive"],
-      ["initializationOrder", ""]
-    ])
-  },
-  smallLED: {
-    id: "smallLED",
-    name: "SmallLED",
-    pins: /* @__PURE__ */ new Map([
-      ["pin1", { subtype: "free", sourceType: void 0 }],
-      ["pin2", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["idleColor", "white"],
-      ["activeColor", "#ffff00"],
-      ["size", "1"],
-      ["ywRatio", "1"]
-    ])
-  },
-  rectangleLED: {
-    id: "rectangleLED",
-    name: "RectangleLED",
-    pins: /* @__PURE__ */ new Map([
-      ["pin1", { subtype: "free", sourceType: void 0 }],
-      ["pin2", { subtype: "free", sourceType: void 0 }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["idleColor", "white"],
-      ["activeColor", "#ffff00"],
-      ["size", "1"],
-      ["hwRatio", "1"],
-      ["ywRatio", "1"]
-    ])
-  },
-  cube: {
-    id: "cube",
-    name: "Cube",
-    pins: /* @__PURE__ */ new Map([]),
-    config: /* @__PURE__ */ new Map([["color", "red"]])
-  },
-  label: {
-    id: "label",
-    name: "Label",
-    pins: /* @__PURE__ */ new Map([]),
-    config: /* @__PURE__ */ new Map([
-      ["text", "Label"],
-      ["size", "1"]
-    ])
-  },
-  inverter: {
-    id: "inverter",
-    name: "Inverter",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "1"],
-      ["initializationOrder", ""]
-    ])
-  },
-  nandGate: {
-    id: "nandGate",
-    name: "NAND Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "1"],
-      ["initializationOrder", ""]
-    ])
-  },
-  nand4Gate: {
-    id: "nand4Gate",
-    name: "NAND4 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "2"],
-      ["initializationOrder", ""]
-    ])
-  },
-  nand8Gate: {
-    id: "nand8Gate",
-    name: "NAND8 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["input5", { subtype: "logicInput", sourceType: void 0 }],
-      ["input6", { subtype: "logicInput", sourceType: void 0 }],
-      ["input7", { subtype: "logicInput", sourceType: void 0 }],
-      ["input8", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "3"],
-      ["initializationOrder", ""]
-    ])
-  },
-  norGate: {
-    id: "norGate",
-    name: "NOR Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "1"],
-      ["initializationOrder", ""]
-    ])
-  },
-  nor4Gate: {
-    id: "nor4Gate",
-    name: "NOR4 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "2"],
-      ["initializationOrder", ""]
-    ])
-  },
-  nor8Gate: {
-    id: "nor8Gate",
-    name: "NOR8 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["input5", { subtype: "logicInput", sourceType: void 0 }],
-      ["input6", { subtype: "logicInput", sourceType: void 0 }],
-      ["input7", { subtype: "logicInput", sourceType: void 0 }],
-      ["input8", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "negative"],
-      ["transitionSpan", "3"],
-      ["initializationOrder", ""]
-    ])
-  },
-  xorGate: {
-    id: "xorGate",
-    name: "XOR Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "positive"],
-      ["transitionSpan", "2"],
-      ["initializationOrder", ""]
-    ])
-  },
-  xor4Gate: {
-    id: "xor4Gate",
-    name: "XOR4 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "positive"],
-      ["transitionSpan", "4"],
-      ["initializationOrder", ""]
-    ])
-  },
-  xor8Gate: {
-    id: "xor8Gate",
-    name: "XOR8 Gate",
-    pins: /* @__PURE__ */ new Map([
-      ["vcc", {
-        subtype: "vcc",
-        sourceType: "Voltage"
-        /* Voltage */
-      }],
-      ["input1", { subtype: "logicInput", sourceType: void 0 }],
-      ["input2", { subtype: "logicInput", sourceType: void 0 }],
-      ["input3", { subtype: "logicInput", sourceType: void 0 }],
-      ["input4", { subtype: "logicInput", sourceType: void 0 }],
-      ["input5", { subtype: "logicInput", sourceType: void 0 }],
-      ["input6", { subtype: "logicInput", sourceType: void 0 }],
-      ["input7", { subtype: "logicInput", sourceType: void 0 }],
-      ["input8", { subtype: "logicInput", sourceType: void 0 }],
-      ["output", { subtype: "logicOutput", sourceType: void 0 }],
-      ["gnd", {
-        subtype: "gnd",
-        sourceType: "Current"
-        /* Current */
-      }]
-    ]),
-    config: /* @__PURE__ */ new Map([
-      ["defaultLogicFamily", "CMOS1"],
-      ["activationLogic", "positive"],
-      ["transitionSpan", "6"],
-      ["initializationOrder", ""]
-    ])
-  }
-};
-class k {
-  /**
-   * Unique identifier for this ENode.
-   * @readonly
-   */
-  id;
-  /**
-   * Type of electrical node (Pin or BranchingPoint).
-   * @readonly
-   */
-  type;
-  /**
-   * Parent component UUID (only for pin nodes).
-   * Undefined for branching point nodes.
-   * @readonly
-   */
-  component;
-  /**
-   * Pin label within component (only for pin nodes).
-   * Undefined for branching point nodes.
-   * @readonly
-   */
-  pinLabel;
-  /**
-   * Grid position (only for branching point nodes).
-   * Undefined for pin nodes (position derived from component).
-   * @readonly
-   */
-  position;
-  /**
-   * Set of wire UUIDs connected to this node.
-   * Mutable to allow wire connections/disconnections.
-   */
-  wires;
-  /**
-   * Is the ENode a source of voltage or current?
-   */
-  source;
-  /**
-   * Pin role classification: free, mainVcc, vcc, mainGnd, gnd, logicInput, logicOutput.
-   * @readonly
-   */
-  subtype;
-  /**
-   * Create a new electrical node.
-   *
-   * **Note**: Typically ENodes are created automatically by Circuit.
-   * This constructor is used internally.
-   *
-   * @param type - Node type (Pin or BranchingPoint)
-   * @param component - Parent component UUID (pin nodes only)
-   * @param pinLabel - Pin label (pin nodes only)
-   * @param position - Grid position (branching points only)
-   * @param source - Source type (Voltage/Current) or undefined
-   *
-   * @param subtype
-   * @example
-   * ```typescript
-   * // Pin node (internal to Circuit)
-   * const pinNode = new ENode(
-   *   ENodeType.Pin,
-   *   componentId,
-   *   '0',  // first pin
-   *   undefined,
-   *   undefined
-   * );
-   *
-   * // Branching point node
-   * const branchNode = new ENode(
-   *   ENodeType.BranchingPoint,
-   *   undefined,
-   *   undefined,
-   *   new Position(15, 25),
-   *   undefined
-   * );
-   * ```
-   */
-  constructor(t, e, i, n, r = void 0, a = "free") {
-    this.id = O(), this.type = t, this.component = e, this.pinLabel = i, this.position = n, this.wires = /* @__PURE__ */ new Set(), this.source = r, this.subtype = a;
-  }
-  /**
-   * Get the position of this electrical node.
-   *
-   * **Pin nodes**: Derives position from parent component.
-   * **Branching nodes**: Returns stored position directly.
-   *
-   * @param circuit - Circuit instance (needed to look up component for pin nodes)
-   * @returns Position on the grid
-   *
-   * @example
-   * ```typescript
-   * const circuit = new Circuit();
-   * const component = circuit.addComponent(
-   *   new Position(10, 20),
-   *   new Rotation(0),
-   *   1
-   * );
-   *
-   * const pinNode = circuit.getENode(component.pins[0]);
-   * const position = pinNode.getPosition(circuit);
-   * console.log(position.x); // 10 (derived from component)
-   * ```
-   */
-  getPosition(t) {
-    if (this.type === S.Pin) {
-      if (!this.component)
-        throw new Error("Pin node missing component reference");
-      const e = t.getComponent(this.component);
-      if (!e)
-        throw new Error(`Component ${this.component} not found for pin node ${this.id}`);
-      return e.position;
-    }
-    if (!this.position)
-      throw new Error("Branching point node missing position");
-    return this.position;
-  }
-  /**
-   * Update the enode (branching point only)'s position.
-   *
-   * @param newPosition - The new position for the enode
-   *
-   * @example
-   * ```typescript
-   * const component = circuit.getComponent(componentId);
-   * component.setPosition(new Position(15, 25));
-   * ```
-   */
-  setPosition(t) {
-    Object.defineProperty(this, "position", {
-      value: t,
-      writable: !1,
-      enumerable: !0,
-      configurable: !0
-    });
-  }
-  /**
-   * Update the enode's source type.
-   * @param sourceType
-   */
-  setSourceType(t) {
-    Object.defineProperty(this, "source", {
-      value: t,
-      writable: !0,
-      enumerable: !0,
-      configurable: !0
-    });
-  }
-  /**
-   * Serialize ENode to JSON.
-   *
-   * @returns Plain object representation
-   *
-   * @example
-   * ```typescript
-   * const json = enode.toJSON();
-   * console.log(json);
-   * // Pin node:
-   * // {
-   * //   id: "uuid",
-   * //   type: "Pin",
-   * //   component: "component-uuid",
-   * //   pinLabel: "0"
-   * // }
-   *
-   * // Branching node:
-   * // {
-   * //   id: "uuid",
-   * //   type: "BranchingPoint",
-   * //   position: { x: 15, y: 25 }
-   * // }
-   * ```
-   */
-  toJSON() {
-    const t = {
-      id: this.id,
-      type: this.type,
-      source: this.source || null,
-      subtype: this.subtype
-    };
-    return this.type === S.Pin ? (t.component = this.component || null, t.pinLabel = this.pinLabel || null) : t.position = this.position?.toJSON() || null, t;
-  }
-  /**
-   * Deserialize ENode from JSON.
-   *
-   * @param json - ENode data
-   * @returns ENode instance
-   *
-   * @example
-   * ```typescript
-   * const json = {
-   *   id: "uuid",
-   *   type: "Pin",
-   *   component: "component-uuid",
-   *   pinLabel: "0"
-   * };
-   *
-   * const enode = ENode.fromJSON(json);
-   * ```
-   */
-  static fromJSON(t) {
-    const e = t.position ? T.fromJSON(t.position) : void 0, i = new k(
-      t.type,
-      t.component || void 0,
-      t.pinLabel || void 0,
-      e,
-      t.source || void 0,
-      t.subtype ?? "free"
-    );
-    return Object.defineProperty(i, "id", {
-      value: t.id,
-      writable: !1,
-      enumerable: !0,
-      configurable: !1
-    }), i;
-  }
-}
-class E {
-  /**
-   * Unique identifier for this component.
-   * @readonly
-   */
-  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 IComponentTypeMetadata for details.
-   *
-   */
-  config;
-  /**
-   * allow to flag a component as non editable (feature to implement)
-   */
-  editable;
-  /**
-   * 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
-   *
-   * @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']
-   * );
-   * ```
-   */
-  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(", ")}`
-      );
-    }
-    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);
-  }
-  /**
-   * 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),
-      editable: this.editable
-    };
-  }
-  /**
-   * Deserialize component from JSON.
-   *
-   * @param json - Component data
-   * @returns Component instance
-   *
-   */
-  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 = {
-  /**
-   * 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
-}, $ = {
-  /**
-   * 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 w {
-  /**
-   * Current simulation step number (starts at 0).
-   * @readonly
-   */
-  tick;
-  /**
-   * Electrical state for each ENode (component pins and branching points).
-   * Key: ENode UUID, Value: INodeElectricalState
-   * @readonly
-   */
-  nodeStates;
-  /**
-   * 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.
-   *
-   * @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 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 D {
-  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 = [];
-  }
-  /**
-   * 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.
-   *
-   * @returns Event count
-   */
-  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);
-      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 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;
-    }
-  }
-  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 P {
-  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;
-  }
-}
-class x {
-  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 w(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 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;
-  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, 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) {
-      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 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;
-  }
-  /**
-   * Execute multiple simulation ticks.
-   *
-   * @param count - Number of ticks to execute
-   * @returns an array of IRunnerResult for each tick executed
-   */
-  tickN(t) {
-    if (t < 1)
-      throw new RangeError(`Tick count must be at least 1 (got ${t})`);
-    const e = [];
-    for (let 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 IBehaviorResult 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
-      );
-      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);
-    }
-    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 s of this.circuit.getAllComponents()) {
-      if (s.pins.length < 1) continue;
-      const u = this.behaviorRegistry.get(s.type);
-      if (!u)
-        continue;
-      const d = u.createInitialState(s);
-      t.componentStates.set(s.id, d), this.dirtyTracker.markComponentDirty(s.id);
-    }
-    for (const s of this.circuit.getAllENodes())
-      t.nodeStates.set(s.id, {
-        hasVoltage: s.source === v.Voltage,
-        hasCurrent: s.source === v.Current,
-        locked: !!s.source
-      });
-    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 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((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 (; 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 b = l.onPinsChange(
-            d,
-            g,
-            t.nodeStates,
-            0
-          );
-          b.hasChanged && (r = !0, t.componentStates.set(
-            d.id,
-            b.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 h = this.updateState(0);
-    return this.dirtyTracker.setDirtyComponents(
-      /* @__PURE__ */ new Set([...this.circuit.getAllComponents().map((s) => s.id)])
-    ), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((s) => s.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((s) => s.id)])), h;
-  }
-  /**
-   * 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(), r = this.circuit.getComponentsOfPins(i), a = /* @__PURE__ */ new Set();
-    let c = 0, h = Array.from(r);
-    t === 0 && (h = h.sort((s, u) => {
-      const d = this.circuit.getComponent(s), l = this.circuit.getComponent(u), g = this.getInitializationOrder(d.config), b = this.getInitializationOrder(l.config);
-      return g !== b ? g - b : s.localeCompare(u);
-    }));
-    for (const s of h) {
-      const u = this.circuit.getComponent(s), d = this.behaviorRegistry.get(u.type);
-      if (!d)
-        continue;
-      const l = d.onPinsChange(
-        u,
-        e.componentStates.get(s),
-        e.nodeStates,
-        t
-      );
-      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), {
-      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 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,
-        u,
-        t.componentStates
-      ), 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 p of d) {
-        const y = t.nodeStates.get(p);
-        y && !y.locked && y[f] && (y[f] = !1, h.add(p));
-      }
-      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 p of l) {
-        const y = t.wireStates.get(p);
-        y && y[f] && (y[f] = !1, s.add(p));
-      }
-      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, ...r]),
-      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(), 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 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 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 d = i.get(s.id);
-        for (const l of s.pins) {
-          if (l === c || n.has(l)) continue;
-          u.allowConductivity(
-            s,
-            d,
-            t,
-            c,
-            l
-          ) && (n.add(l), a.push(l));
-        }
-      }
-    }
-    return { nodes: n, wires: r };
-  }
-  /**
-   * 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 r of i) {
-      const a = this.circuit.getComponent(r.targetId), c = this.behaviorRegistry.get(a.type);
-      if (!c)
-        continue;
-      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,
-  U as D,
-  v as E,
-  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-BQQlhwjD.js.map