simple-circuit-engine 0.0.1

package/dist/CircuitRunner-CAeE31M5.js

@@ -0,0 +1,1477 @@
+class w {
+  /**
+   * Create a new 3D position.
+   *
+   * @param x - X coordinate
+   * @param y - Y coordinate
+   * @param z - Z coordinate
+   */
+  constructor(t, e, r) {
+    this.x = t, this.y = e, this.z = r;
+  }
+  /**
+   * 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 k {
+  /**
+   * 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), r = 75, i = 0.1, o = 1e3) {
+    this.position = t, this.lookAtPosition = e, this.fov = r, this.near = i, this.far = o;
+  }
+  /**
+   * 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 k(
+      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 S = /* @__PURE__ */ ((n) => (n.Voltage = "Voltage", n.Current = "Current", n))(S || {}), T = /* @__PURE__ */ ((n) => (n.Battery = "battery", n.Switch = "switch", n.Lightbulb = "lightbulb", n.Relay = "relay", n.Transistor = "transistor", n.SmallLED = "smallLED", n.RectangleLED = "rectangleLED", n.Cube = "cube", n.Label = "label", n))(T || {});
+const E = {
+  switch: {
+    id: "switch",
+    name: "Switch",
+    pins: /* @__PURE__ */ new Map([
+      ["input", void 0],
+      ["output", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["initialState", "open"],
+      ["size", "1"]
+    ])
+  },
+  battery: {
+    id: "battery",
+    name: "Battery",
+    pins: /* @__PURE__ */ new Map([
+      ["cathode", S.Voltage],
+      ["anode", S.Current]
+    ]),
+    config: /* @__PURE__ */ new Map([])
+  },
+  lightbulb: {
+    id: "lightbulb",
+    name: "Lightbulb",
+    pins: /* @__PURE__ */ new Map([
+      ["pin1", void 0],
+      ["pin2", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([["size", "1"]])
+  },
+  relay: {
+    id: "relay",
+    name: "Relay",
+    pins: /* @__PURE__ */ new Map([
+      ["cmd_in", void 0],
+      ["cmd_out", void 0],
+      ["power_in", void 0],
+      ["power_out", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["activationLogic", "positive"],
+      ["initializationOrder", ""]
+    ])
+  },
+  transistor: {
+    id: "transistor",
+    name: "Transistor",
+    pins: /* @__PURE__ */ new Map([
+      ["collector", void 0],
+      ["base", void 0],
+      ["emitter", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["activationLogic", "positive"],
+      ["initializationOrder", ""]
+    ])
+  },
+  smallLED: {
+    id: "smallLED",
+    name: "SmallLED",
+    pins: /* @__PURE__ */ new Map([
+      ["cathode", void 0],
+      ["anode", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["mode", "symmetric"],
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  rectangleLED: {
+    id: "rectangleLED",
+    name: "RectangleLED",
+    pins: /* @__PURE__ */ new Map([
+      ["cathode", void 0],
+      ["anode", void 0]
+    ]),
+    config: /* @__PURE__ */ new Map([
+      ["mode", "symmetric"],
+      ["idleColor", "white"],
+      ["activeColor", "#ffff00"],
+      ["size", "1"],
+      ["hwRatio", "1"],
+      ["ywRatio", "1"]
+    ])
+  },
+  cube: {
+    id: "cube",
+    name: "Cube",
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([["color", "red"]])
+  },
+  label: {
+    id: "label",
+    name: "Label",
+    pins: /* @__PURE__ */ new Map([]),
+    config: /* @__PURE__ */ new Map([
+      ["text", "Label"],
+      ["size", "1"]
+    ])
+  }
+};
+function z() {
+  return Object.values(T);
+}
+function N(n) {
+  return E[n];
+}
+var M = /* @__PURE__ */ ((n) => (n.Pin = "Pin", n.BranchingPoint = "BranchingPoint", n))(M || {});
+function I() {
+  if (typeof crypto < "u" && crypto.randomUUID)
+    return crypto.randomUUID();
+  const n = "0123456789abcdef", t = [8, 4, 4, 4, 12], e = [];
+  for (const c of t) {
+    let l = "";
+    for (let s = 0; s < c; s++) {
+      const h = Math.floor(Math.random() * 16);
+      l += n[h];
+    }
+    e.push(l);
+  }
+  const i = e.join("-").split("");
+  i[14] = "4";
+  const a = parseInt(i[19] ?? "0", 16) & 3 | 8;
+  return i[19] = n[a] ?? "0", i.join("");
+}
+class v {
+  /**
+   * 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 v(t.x, t.y);
+  }
+  /**
+   * String representation for debugging.
+   *
+   * @returns String in format "Position(x, y)"
+   */
+  toString() {
+    return `Position(${this.x}, ${this.y})`;
+  }
+}
+function W(n, t, e = 1 / 0) {
+  if (n.length === 0)
+    return 0;
+  if (n.length === 1)
+    return 1;
+  let r = 1;
+  for (let i = 0; i < n.length - 1; i++) {
+    const o = n[i], a = n[i + 1], c = O(t, o, a);
+    c < e && (e = c, r = i + 1);
+  }
+  return r;
+}
+function O(n, t, e) {
+  const r = e.x - t.x, i = e.y - t.y, o = r * r + i * i;
+  if (o === 0)
+    return Math.sqrt((n.x - t.x) ** 2 + (n.y - t.y) ** 2);
+  const a = Math.max(
+    0,
+    Math.min(
+      1,
+      ((n.x - t.x) * r + (n.y - t.y) * i) / o
+    )
+  ), c = t.x + a * r, l = t.y + a * i;
+  return Math.sqrt((n.x - c) ** 2 + (n.y - l) ** 2);
+}
+function L(n, t = 5) {
+  if (n.length <= 2)
+    return [...n];
+  const e = [n[0]];
+  for (let r = 1; r < n.length - 1; r++) {
+    const i = e[e.length - 1], o = n[r], a = n[r + 1];
+    D(i, o, a, t) || e.push(o);
+  }
+  return e.push(n[n.length - 1]), e;
+}
+function D(n, t, e, r = 5) {
+  const i = (t.x - n.x) * (e.y - n.y) - (t.y - n.y) * (e.x - n.x);
+  return Math.abs(i) <= r;
+}
+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}°)`;
+  }
+}
+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, r, i) {
+    if (this.id = I(), this.type = t, this.position = e, this.rotation = r, new Set(i).size !== i.length) {
+      const o = i.filter((a, c) => i.indexOf(a) !== c);
+      throw new Error(
+        `Duplicate pin names are not allowed: ${[...new Set(o)].join(", ")}`
+      );
+    }
+    this.pins = i, this.config = new Map(E[t].config);
+  }
+  getPinLabel(t) {
+    const e = this.pins.indexOf(t);
+    if (e === -1)
+      return;
+    const r = N(this.type).pins.keys();
+    return Array.from(r)[e] || void 0;
+  }
+  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,
+      v.fromJSON(t.position),
+      C.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 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 [o, a] of this.nodeStates.entries())
+      e.set(o, { ...a });
+    const r = /* @__PURE__ */ new Map();
+    for (const [o, a] of this.wireStates.entries())
+      r.set(o, { ...a });
+    const i = /* @__PURE__ */ new Map();
+    for (const [o, a] of this.componentStates.entries())
+      i.set(
+        o,
+        Object.assign(Object.create(Object.getPrototypeOf(a)), a)
+      );
+    return Object.defineProperty(t, "nodeStates", {
+      value: e,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "wireStates", {
+      value: r,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), Object.defineProperty(t, "componentStates", {
+      value: i,
+      writable: !1,
+      configurable: !1,
+      enumerable: !0
+    }), t;
+  }
+}
+class R {
+  currentState;
+  history;
+  historyEnabled;
+  historyLimit;
+  historyWriteIndex;
+  /**
+   * Create a new state controllerType.
+   *
+   * @param enableHistory - Whether to store state history (default: false)
+   * @param historyLimit - Maximum number of historical states to keep (default: 1000)
+   */
+  constructor(t = !1, e = 1e3) {
+    if (e < 1)
+      throw new RangeError(`historyLimit must be at least 1 (got ${e})`);
+    this.historyEnabled = t, this.historyLimit = e, this.currentState = new b(0), this.history = [], this.historyWriteIndex = 0;
+  }
+  /**
+   * Get the current simulation state.
+   *
+   * @returns Current state (mutable for simulation controller use)
+   */
+  getCurrentState() {
+    return this.currentState;
+  }
+  /**
+   * Get current tick number.
+   *
+   * @returns Current simulation tick
+   */
+  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 x {
+  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 r = this.extractMin();
+      r && e.push(r);
+    }
+    return e.sort((r, i) => r.readyAtTick === i.readyAtTick ? r.scheduledAtTick - i.scheduledAtTick : r.readyAtTick - i.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 r = 2 * t + 1, i = 2 * t + 2;
+      let o = t;
+      if (r < e && this.heap[r].readyAtTick < this.heap[o].readyAtTick && (o = r), i < e && this.heap[i].readyAtTick < this.heap[o].readyAtTick && (o = i), o !== t)
+        [this.heap[t], this.heap[o]] = [this.heap[o], this.heap[t]], t = o;
+      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;
+  }
+}
+const U = {
+  /**
+   * 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: 2,
+  /**
+   * 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 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, r = {}) {
+    this.circuit = t, this.behaviorRegistry = e;
+    const i = r.enableHistory ?? !1, o = r.historyLimit ?? 1e3;
+    this.stateManager = new R(i, o), this.eventQueue = new x(), this.commands = /* @__PURE__ */ new Map(), this.dirtyTracker = new P();
+    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(), r = this.applyReadyEvents(e + 1), i = this.updateState(e + 1);
+    i.firedEventCount = r.length;
+    const o = this.processCommands();
+    i.processedCommandCount = o.length, i.scheduledEventCount = this.eventQueue.size() + i.firedEventCount - t;
+    for (const a of r)
+      a.hasChanged && this.dirtyTracker.markComponentDirty(a.componentState.componentId);
+    return i.componentUpdateCount = this.dirtyTracker.getDirtyComponentCount(), this.stateManager.advanceToNextTick(), i.endTick = this.stateManager.getCurrentTick(), i;
+  }
+  /**
+   * 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 r = 0; r < t; r++)
+      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 r of this.commands.values()) {
+      const i = this.circuit.getComponent(r.targetId), a = this.behaviorRegistry.get(i.type).onUserCommand(
+        i,
+        t.componentStates.get(i.id),
+        r
+      );
+      for (const c of a.scheduledEvents)
+        this.eventQueue.schedule(c);
+      e.push(a), a.hasChanged && this.dirtyTracker.markComponentDirty(i.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 r = parseInt(e, 10);
+    return isNaN(r) ? 0 : r;
+  }
+  /**
+   * 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 h = this.behaviorRegistry.get(s.type);
+      if (!h)
+        continue;
+      const u = h.createInitialState(s);
+      t.componentStates.set(s.id, u), this.dirtyTracker.markComponentDirty(s.id);
+    }
+    for (const s of this.circuit.getAllENodes())
+      t.nodeStates.set(s.id, {
+        hasVoltage: s.source === S.Voltage,
+        hasCurrent: s.source === S.Current,
+        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(), r = /* @__PURE__ */ new Map();
+    for (const s of e) {
+      const h = this.getInitializationOrder(s.config), u = r.get(h) ?? [];
+      u.push(s), r.set(h, u);
+    }
+    const i = Array.from(r.keys()).sort((s, h) => s - h);
+    for (const s of i)
+      r.get(s).sort((u, g) => u.id.localeCompare(g.id));
+    let o = !0, a = 0;
+    const c = 100;
+    for (; o && a < c; ) {
+      o = !1, a++;
+      for (const s of i) {
+        const h = r.get(s);
+        for (const u of h) {
+          const g = this.behaviorRegistry.get(u.type);
+          if (!g) continue;
+          const f = t.componentStates.get(u.id);
+          if (!f) continue;
+          this.propagateConductivity();
+          const m = g.onPinsChange(
+            u,
+            f,
+            t.nodeStates,
+            0
+          );
+          m.hasChanged && (o = !0, t.componentStates.set(
+            u.id,
+            m.componentState
+          ));
+          for (const y of m.scheduledEvents) {
+            const d = g.onEventFiring(u, f, y);
+            d.hasChanged && (o = !0, t.componentStates.set(
+              u.id,
+              d.componentState
+            ));
+          }
+        }
+      }
+    }
+    const l = this.updateState(0);
+    return this.dirtyTracker.setDirtyComponents(
+      /* @__PURE__ */ new Set([...this.circuit.getAllComponents().map((s) => s.id)])
+    ), this.dirtyTracker.setDirtyEnodes(/* @__PURE__ */ new Set([...this.circuit.getAllENodes().map((s) => s.id)])), this.dirtyTracker.setDirtyWires(/* @__PURE__ */ new Set([...this.circuit.getAllWires().map((s) => s.id)])), l;
+  }
+  /**
+   * 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: r, updatedWires: i } = this.propagateConductivity(), o = this.circuit.getComponentsOfPins(r), a = /* @__PURE__ */ new Set();
+    let c = 0, l = Array.from(o);
+    t === 0 && (l = l.sort((s, h) => {
+      const u = this.circuit.getComponent(s), g = this.circuit.getComponent(h), f = this.getInitializationOrder(u.config), m = this.getInitializationOrder(g.config);
+      return f !== m ? f - m : s.localeCompare(h);
+    }));
+    for (const s of l) {
+      const h = this.circuit.getComponent(s), u = this.behaviorRegistry.get(h.type);
+      if (!u)
+        continue;
+      const g = u.onPinsChange(
+        h,
+        e.componentStates.get(s),
+        e.nodeStates,
+        t
+      );
+      g.hasChanged && a.add(s);
+      for (const f of g.scheduledEvents)
+        this.eventQueue.schedule(f), c++;
+    }
+    return this.dirtyTracker.setDirtyComponents(a), this.dirtyTracker.setDirtyEnodes(r), this.dirtyTracker.setDirtyWires(i), {
+      startTick: this.getCurrentTick(),
+      endTick: this.getCurrentTick(),
+      componentUpdateCount: a.size,
+      nodeUpdateCount: r.size,
+      wireUpdateCount: i.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(), s = /* @__PURE__ */ new Set(), h = this.circuit.getAllENodes().filter((d) => d.source == c).map((d) => d.id), u = /* @__PURE__ */ new Set([
+        ...this.circuit.getAllENodes().filter((d) => !d.source).map((d) => d.id)
+      ]), g = /* @__PURE__ */ new Set([...this.circuit.getAllWires().map((d) => d.id)]), { nodes: f, wires: m } = this.computeReachability(
+        c,
+        h,
+        t.componentStates
+      ), y = c == S.Voltage ? "hasVoltage" : "hasCurrent";
+      for (const d of f) {
+        const p = t.nodeStates.get(d);
+        p && !p.locked && (p[y] || (p[y] = !0, l.add(d)), u.delete(d));
+      }
+      for (const d of u) {
+        const p = t.nodeStates.get(d);
+        p && !p.locked && p[y] && (p[y] = !1, l.add(d));
+      }
+      for (const d of m) {
+        const p = t.wireStates.get(d);
+        p && (p[y] || (p[y] = !0, s.add(d)), g.delete(d));
+      }
+      for (const d of g) {
+        const p = t.wireStates.get(d);
+        p && p[y] && (p[y] = !1, s.add(d));
+      }
+      return { updatedNodes: l, updatedWires: s };
+    }, { updatedNodes: r, updatedWires: i } = e(S.Voltage), { updatedNodes: o, updatedWires: a } = e(S.Current);
+    return {
+      updatedNodes: /* @__PURE__ */ new Set([...r, ...o]),
+      updatedWires: /* @__PURE__ */ new Set([...i, ...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, r) {
+    const i = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), a = [];
+    for (const c of e)
+      a.push(c), i.add(c);
+    for (; a.length > 0; ) {
+      const c = a.shift();
+      for (const s of this.circuit.getWiresByNode(c)) {
+        const h = s.node1 === c ? s.node2 : s.node1;
+        i.has(h) || (i.add(h), a.push(h)), o.has(s.id) || o.add(s.id);
+      }
+      const l = this.circuit.getENode(c);
+      if (l.type === M.Pin) {
+        const s = this.circuit.getComponent(l.component), h = this.behaviorRegistry.get(s.type);
+        if (!h)
+          continue;
+        const u = r.get(s.id);
+        for (const g of s.pins) {
+          if (g === c || i.has(g)) continue;
+          h.allowConductivity(
+            s,
+            u,
+            t,
+            c,
+            g
+          ) && (i.add(g), a.push(g));
+        }
+      }
+    }
+    return { nodes: i, wires: o };
+  }
+  /**
+   * 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(), r = this.eventQueue.getReadyEvents(t), i = [];
+    for (const o of r) {
+      const a = this.circuit.getComponent(o.targetId), c = this.behaviorRegistry.get(a.type);
+      if (!c)
+        continue;
+      const l = e.componentStates.get(a.id), s = c.onEventFiring(a, l, o);
+      for (const h of s.scheduledEvents)
+        this.eventQueue.schedule(h);
+      i.push(s);
+    }
+    return i;
+  }
+}
+export {
+  k as C,
+  P as D,
+  S as E,
+  v as P,
+  C as R,
+  b as S,
+  $ as T,
+  T as a,
+  E as b,
+  N as c,
+  M as d,
+  I as e,
+  W as f,
+  z as g,
+  w as h,
+  A as i,
+  J as j,
+  R as k,
+  U as l,
+  x as m,
+  L as s
+};
+//# sourceMappingURL=CircuitRunner-CAeE31M5.js.map