simple-circuit-engine 0.0.1

package/dist/core/index.js

@@ -0,0 +1,1683 @@
+import { e as T, d as g, P, C as b, c as _, i as C, f as A, b as L, s as E, a as p, T as y } from "../CircuitRunner-CAeE31M5.js";
+import { j as Z, D as j, E as ee, m as te, h as ne, R as ie, l as se, S as oe, k as re, g as ae } from "../CircuitRunner-CAeE31M5.js";
+class w {
+  /**
+   * Unique identifier for this ENode.
+   * @readonly
+   */
+  id;
+  /**
+   * Type of electrical node (Pin or BranchingPoint).
+   * @readonly
+   */
+  type;
+  /**
+   * Parent component UUID (only for pin nodes).
+   * Undefined for branching point nodes.
+   * @readonly
+   */
+  component;
+  /**
+   * Pin label within component (only for pin nodes).
+   * Undefined for branching point nodes.
+   * @readonly
+   */
+  pinLabel;
+  /**
+   * Grid position (only for branching point nodes).
+   * Undefined for pin nodes (position derived from component).
+   * @readonly
+   */
+  position;
+  /**
+   * Set of wire UUIDs connected to this node.
+   * Mutable to allow wire connections/disconnections.
+   */
+  wires;
+  /**
+   * Is the ENode a source of voltage or current?
+   */
+  source;
+  /**
+   * Create a new electrical node.
+   *
+   * **Note**: Typically ENodes are created automatically by Circuit.
+   * This constructor is used internally.
+   *
+   * @param type - Node type (Pin or BranchingPoint)
+   * @param component - Parent component UUID (pin nodes only)
+   * @param pinLabel - Pin label (pin nodes only)
+   * @param position - Grid position (branching points only)
+   * @param source - Source type (Voltage/Current) or undefined
+   *
+   * @example
+   * ```typescript
+   * // Pin node (internal to Circuit)
+   * const pinNode = new ENode(
+   *   ENodeType.Pin,
+   *   componentId,
+   *   '0',  // first pin
+   *   undefined,
+   *   undefined
+   * );
+   *
+   * // Branching point node
+   * const branchNode = new ENode(
+   *   ENodeType.BranchingPoint,
+   *   undefined,
+   *   undefined,
+   *   new Position(15, 25),
+   *   undefined
+   * );
+   * ```
+   */
+  constructor(e, t, i, n, s = void 0) {
+    this.id = T(), this.type = e, this.component = t, this.pinLabel = i, this.position = n, this.wires = /* @__PURE__ */ new Set(), this.source = s;
+  }
+  /**
+   * Get the position of this electrical node.
+   *
+   * **Pin nodes**: Derives position from parent component.
+   * **Branching nodes**: Returns stored position directly.
+   *
+   * @param circuit - Circuit instance (needed to look up component for pin nodes)
+   * @returns Position on the grid
+   *
+   * @example
+   * ```typescript
+   * const circuit = new Circuit();
+   * const component = circuit.addComponent(
+   *   new Position(10, 20),
+   *   new Rotation(0),
+   *   1
+   * );
+   *
+   * const pinNode = circuit.getENode(component.pins[0]);
+   * const position = pinNode.getPosition(circuit);
+   * console.log(position.x); // 10 (derived from component)
+   * ```
+   */
+  getPosition(e) {
+    if (this.type === g.Pin) {
+      if (!this.component)
+        throw new Error("Pin node missing component reference");
+      const t = e.getComponent(this.component);
+      if (!t)
+        throw new Error(`Component ${this.component} not found for pin node ${this.id}`);
+      return t.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(e) {
+    Object.defineProperty(this, "position", {
+      value: e,
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    });
+  }
+  /**
+   * Update the enode's source type.
+   * @param sourceType
+   */
+  setSourceType(e) {
+    Object.defineProperty(this, "source", {
+      value: e,
+      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 e = {
+      id: this.id,
+      type: this.type,
+      source: this.source || null
+    };
+    return this.type === g.Pin ? (e.component = this.component || null, e.pinLabel = this.pinLabel || null) : e.position = this.position?.toJSON() || null, e;
+  }
+  /**
+   * 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(e) {
+    const t = e.position ? P.fromJSON(e.position) : void 0, i = new w(e.type, e.component, e.pinLabel, t, e.source);
+    return Object.defineProperty(i, "id", {
+      value: e.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}
+class f {
+  /**
+   * Unique identifier for this wire.
+   * @readonly
+   */
+  id;
+  /**
+   * First connected ENode UUID.
+   * @readonly
+   */
+  node1;
+  /**
+   * Second connected ENode UUID.
+   * @readonly
+   */
+  node2;
+  /**
+   * Optional intermediate positions for wire routing.
+   * Empty array indicates straight-line connection.
+   * @readonly
+   */
+  intermediatePositions;
+  /**
+   * Create a new wire.
+   *
+   * **Note**: Typically wires are created via `Circuit.addWire()` which
+   * handles validation and bidirectional reference updates. This constructor
+   * is used internally by Circuit.
+   *
+   * @param node1 - First ENode UUID
+   * @param node2 - Second ENode UUID
+   * @param intermediatePositions - Optional waypoints for rendering
+   *
+   * @example
+   * ```typescript
+   * // Usually created via Circuit:
+   * const wire = circuit.addWire(nodeId1, nodeId2);
+   *
+   * // With intermediate positions:
+   * const wire = circuit.addWire(
+   *   nodeId1,
+   *   nodeId2,
+   *   [new Position(5, 10), new Position(15, 10)]
+   * );
+   * ```
+   */
+  constructor(e, t, i = []) {
+    this.id = T(), this.node1 = e, this.node2 = t, this.intermediatePositions = i;
+  }
+  /**
+   * Check if this is a straight-line wire.
+   *
+   * @returns true if no intermediate positions, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const straightWire = new Wire(node1, node2);
+   * console.log(straightWire.isStraightLine()); // true
+   *
+   * const curvedWire = new Wire(node1, node2, [new Position(5, 5)]);
+   * console.log(curvedWire.isStraightLine()); // false
+   * ```
+   */
+  isStraightLine() {
+    return this.intermediatePositions.length === 0;
+  }
+  /**
+   * Serialize wire to JSON.
+   *
+   * @returns Plain object representation
+   *
+   * @example
+   * ```typescript
+   * const json = wire.toJSON();
+   * console.log(json);
+   * // {
+   * //   id: "uuid",
+   * //   node1: "node-uuid-1",
+   * //   node2: "node-uuid-2",
+   * //   intermediatePositions: [{ x: 5, y: 10 }]
+   * // }
+   * ```
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      node1: this.node1,
+      node2: this.node2,
+      intermediatePositions: this.intermediatePositions.map((e) => e.toJSON())
+    };
+  }
+  /**
+   * Deserialize wire from JSON.
+   *
+   * @param json - Wire data
+   * @returns Wire instance
+   *
+   * @example
+   * ```typescript
+   * const json = {
+   *   id: "uuid",
+   *   node1: "node-uuid-1",
+   *   node2: "node-uuid-2",
+   *   intermediatePositions: [{ x: 5, y: 10 }]
+   * };
+   *
+   * const wire = Wire.fromJSON(json);
+   * ```
+   */
+  static fromJSON(e) {
+    const t = e.intermediatePositions.map((n) => P.fromJSON(n)), i = new f(e.node1, e.node2, t);
+    return Object.defineProperty(i, "id", {
+      value: e.id,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), i;
+  }
+}
+class v {
+  /**
+   * Create a new CircuitMetadata holding general information about the Circuit.
+   *
+   * @param name - Name of the circuit
+   * @param size - Size of the circuit grid
+   * @param divisions - Divisions in the circuit grid
+   * @param cameraOptions - Camera Options at startup
+   * @throws {TypeError} If size or divisions are not integers
+   */
+  constructor(e, t, i, n) {
+    if (this.name = e, this.size = t, this.divisions = i, this.cameraOptions = n, !Number.isInteger(t) || !Number.isInteger(i))
+      throw new TypeError(
+        `Size and divisions must be integers (got size=${t}, divisions=${i})`
+      );
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      size: this.size,
+      divisions: this.divisions,
+      cameraOptions: this.cameraOptions.toJSON()
+    };
+  }
+  static fromJSON(e) {
+    return new v(
+      e.name,
+      e.size,
+      e.divisions,
+      b.fromJSON(e.cameraOptions)
+    );
+  }
+  toString() {
+    return `CircuitMetadata(${this.name}, ${this.size}, ${this.divisions}, ${this.cameraOptions.toString()})`;
+  }
+}
+class O {
+  /**
+   * Circuit metadata holding general information.
+   * @private
+   */
+  metadata;
+  /**
+   * Map of all components in the circuit (UUID → Component).
+   * @private
+   */
+  components;
+  /**
+   * Map of all electrical nodes in the circuit (UUID → ENode).
+   * Includes both pin nodes and branching point nodes.
+   * @private
+   */
+  enodes;
+  /**
+   * Map of all wires in the circuit (UUID → Wire).
+   * @private
+   */
+  wires;
+  /**
+   * Create a new empty circuit.
+   */
+  constructor(e = "Untitled Circuit") {
+    this.metadata = new v(e, 10, 10, new b()), this.components = /* @__PURE__ */ new Map(), this.enodes = /* @__PURE__ */ new Map(), this.wires = /* @__PURE__ */ new Map();
+  }
+  get name() {
+    return this.metadata.name;
+  }
+  set name(e) {
+    if (typeof e != "string" || e.trim() === "")
+      throw new TypeError("Circuit name must be a non-empty string");
+    this.metadata.name = e;
+  }
+  /**
+   * Add a new component to the circuit.
+   *
+   * Automatically creates pin ENodes for the component and links them
+   * bidirectionally. Pin ENode UUIDs are stored in the component's pins array.
+   * Pin labels are derived from the ComponentType metadata.
+   *
+   * @param type - Component type (Battery, Switch, LED, etc.)
+   * @param position - Grid position (x, y integers)
+   * @param rotation - Orientation angle (integer degrees)
+   * @param config - Optional configuration map for component-specific settings
+   * @returns The created Component
+   * @throws {TypeError} If position/rotation coordinates are not integers
+   *
+   * @example
+   * ```typescript
+   * const lightbulb = circuit.addComponent(
+   *   new Position(10, 20),
+   *   new Rotation(90),
+   *   ComponentType.Lightbulb
+   * );
+   *
+   * console.log(lightbulb.type);        // ComponentType.Lightbulb
+   * console.log(lightbulb.pins.length); // 2
+   * console.log(lightbulb.position.x);  // 10
+   * ```
+   */
+  addComponent(e, t, i, n) {
+    const s = _(e), o = new C(e, t, i, []);
+    n && (o.config = new Map(n));
+    const a = [];
+    for (const [r, c] of s.pins) {
+      const l = new w(
+        g.Pin,
+        o.id,
+        r,
+        void 0,
+        // Pin position derived from component,
+        c
+      );
+      this.enodes.set(l.id, l), a.push(l.id);
+    }
+    return Object.defineProperty(o, "pins", {
+      value: a,
+      writable: !1,
+      enumerable: !0,
+      configurable: !1
+    }), this.components.set(o.id, o), o;
+  }
+  /**
+   * Remove a component from the circuit.
+   *
+   * **Cascade deletion** removes:
+   * - All pin ENodes belonging to the component
+   * - All Wires connected to those pins
+   *
+   * @param id - Component UUID
+   * @throws {Error} If component does not exist
+   * @returns Object containing arrays of deleted Wires and ENodes IDs
+   *
+   * @example
+   * ```typescript
+   * circuit.removeComponent(componentId);
+   * // Component, its pins, and connected wires are all removed
+   * ```
+   */
+  removeComponent(e) {
+    const t = this.components.get(e);
+    if (!t)
+      throw new Error(`Component ${e} does not exist`);
+    const i = [], n = [];
+    for (const s of t.pins) {
+      const o = this.enodes.get(s);
+      if (o) {
+        const a = Array.from(o.wires);
+        for (const r of a)
+          this.removeWire(r), i.push(r);
+      }
+      this.enodes.delete(s), n.push(s);
+    }
+    return this.components.delete(e), { deletedWires: i, deletedENodes: n };
+  }
+  hasComponent(e) {
+    return this.components.has(e);
+  }
+  /**
+   * Get a component by ID.
+   *
+   * @param id - Component UUID
+   * @returns The Component or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * const component = circuit.getComponent(componentId);
+   * if (component) {
+   *   console.log(component.position);
+   * }
+   * ```
+   */
+  getComponent(e) {
+    return this.components.get(e);
+  }
+  /**
+   * Get all components in the circuit.
+   *
+   * Returns a new array on each call (defensive copy).
+   *
+   * @returns Array of all Components
+   *
+   * @example
+   * ```typescript
+   * const components = circuit.getAllComponents();
+   * console.log(`Circuit has ${components.length} components`);
+   *
+   * for (const comp of components) {
+   *   console.log(comp.id, comp.position);
+   * }
+   * ```
+   */
+  getAllComponents() {
+    return Array.from(this.components.values());
+  }
+  getAllComponentsByType(e) {
+    const t = [];
+    for (const i of this.components.values())
+      i.type === e && t.push(i);
+    return t;
+  }
+  getFirstComponentOfType(e) {
+    for (const t of this.components.values())
+      if (t.type === e)
+        return t;
+  }
+  /**
+   * Get an electrical node by ID.
+   *
+   * Note: ENodes are automatically managed and not directly created
+   * or removed by users.
+   *
+   * @param id - ENode UUID
+   * @returns The ENode or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * const component = circuit.addComponent(
+   *   new Position(10, 20),
+   *   new Rotation(0),
+   *   2
+   * );
+   *
+   * const pinId = component.pins[0];
+   * const enode = circuit.getENode(pinId);
+   * console.log(enode.type); // ENodeType.Pin
+   * ```
+   */
+  getENode(e) {
+    return this.enodes.get(e);
+  }
+  /**
+   * Get all electrical nodes in the circuit.
+   *
+   * Includes both pin nodes (from components) and branching point nodes
+   * (from wire splits).
+   *
+   * Returns a new array on each call (defensive copy).
+   *
+   * @returns Array of all ENodes
+   *
+   * @example
+   * ```typescript
+   * const enodes = circuit.getAllENodes();
+   * console.log(`Circuit has ${enodes.length} electrical nodes`);
+   *
+   * for (const enode of enodes) {
+   *   console.log(enode.id, enode.type);
+   * }
+   * ```
+   */
+  getAllENodes() {
+    return Array.from(this.enodes.values());
+  }
+  /**
+   * Add a branching point electrical node at a specific position.
+   *
+   * Branching points are used to split wires and create junctions.
+   * @param position - Grid position for the branching point
+   * @param sourceType - Optional source type (voltage/current)
+   * @returns The created ENode
+   */
+  addBranchingPoint(e, t) {
+    const i = new w(
+      g.BranchingPoint,
+      void 0,
+      void 0,
+      e,
+      t
+    );
+    return this.enodes.set(i.id, i), i;
+  }
+  /**
+   * Remove a branching point electrical node from the circuit.
+   * Also removes all wires connected to this branching point if there are ony one or more than 2.
+   * In the case there are exactly two wires, they will be merged before removing the branching point.
+   *
+   * @param id - Branching point ENode UUID
+   * @throws {Error} If ENode does not exist or is not a branching point
+   */
+  removeBranchingPoint(e) {
+    const t = this.enodes.get(e);
+    if (!t)
+      throw new Error(`Enode ${e} does not exist`);
+    if (t.type !== g.BranchingPoint)
+      throw new Error(
+        `Enode ${e} is not a branching point, it must be removed with its component.`
+      );
+    const i = {}, n = this.getWiresByNode(e);
+    if (n.length === 1 || n.length > 2) {
+      const s = [];
+      for (const o of n)
+        this.removeWire(o.id), s.push(o.id);
+      Object.assign(i, { deletedWires: s });
+    } else if (n.length === 2) {
+      const s = n[0], o = n[1], a = s.node1 === e ? s.node2 : s.node1, r = o.node1 === e ? o.node2 : o.node1, c = [];
+      a === s.node1 ? c.push(...s.intermediatePositions) : a === s.node2 && c.push(...[...s.intermediatePositions].reverse()), c.push(t.getPosition(this)), r === o.node1 ? c.push(...[...o.intermediatePositions].reverse()) : r === o.node2 && c.push(...o.intermediatePositions), this.removeWire(s.id), this.removeWire(o.id);
+      const l = this.addWire(a, r, c);
+      if (l instanceof Error)
+        throw new Error(`Failed to merge wires at branching point ${e}: ${l.message}`);
+      Object.assign(i, { mergedWires: [s.id, o.id] }), Object.assign(i, { newWire: l });
+    }
+    return this.enodes.delete(e), i;
+  }
+  /**
+   * Add a wire connecting two electrical nodes.
+   *
+   * Validates that both nodes exist, not a self-connection, and no duplicate.
+   * Updates bidirectional references (Wire ↔ ENodes).
+   *
+   * @param node1 - First ENode UUID
+   * @param node2 - Second ENode UUID
+   * @param intermediatePositions - Optional path waypoints for rendering
+   * @returns The created Wire, or Error if validation fails
+   *
+   * @example
+   * ```typescript
+   * const comp1 = circuit.addComponent(new Position(0, 0), new Rotation(0), 1);
+   * const comp2 = circuit.addComponent(new Position(10, 10), new Rotation(0), 1);
+   *
+   * const wire = circuit.addWire(comp1.pins[0], comp2.pins[0]);
+   * if (wire instanceof Error) {
+   *   console.error('Failed:', wire.message);
+   * }
+   * ```
+   */
+  addWire(e, t, i) {
+    if (e === t)
+      return new Error("Cannot create wire connecting node to itself");
+    const n = this.enodes.get(e), s = this.enodes.get(t);
+    if (!n || !s)
+      return new Error("Wire requires at least one existing ENode");
+    if (this.hasWireBetween(e, t))
+      return new Error("Duplicate wire between same nodes");
+    const o = new f(e, t, i || []);
+    return this.wires.set(o.id, o), n.wires.add(o.id), s.wires.add(o.id), o;
+  }
+  /**
+   * Remove a wire from the circuit.
+   *
+   * @param id - Wire UUID
+   * @throws {Error} If wire does not exist
+   *
+   * @example
+   * ```typescript
+   * circuit.removeWire(wireId);
+   * // Wire is removed
+   * ```
+   */
+  removeWire(e) {
+    const t = this.wires.get(e);
+    if (!t)
+      throw new Error(`Wire ${e} does not exist`);
+    const i = this.enodes.get(t.node1), n = this.enodes.get(t.node2);
+    i && i.wires.delete(e), n && n.wires.delete(e), this.wires.delete(e);
+  }
+  /**
+   * Split a wire in the circuit.
+   *
+   * It creates two new wires connected by either the target enode or a new branching point ENode at the specified position.
+   * Returns 2 UUIDS of the new wires.
+   *
+   * @param id - Wire UUID
+   * @param position
+   * @throws {Error} If wire does not exist
+   *
+   * @example
+   * ```typescript
+   * circuit.splitWire(wireId);
+   * // Wire and any orphaned branching points are removed
+   * ```
+   */
+  /**
+   * Split an existing wire at a position, creating a branching point.
+   * The original wire is removed and replaced with two new wires
+   * connecting through the new branching point.
+   * NB : in the special case where targetEnode belongs to a component where the wire is already connected
+   * only one new wire will be created as this method don't allow a wire directly connecting two pins of the same component.
+   *
+   * @param wireId - Wire to split
+   * @param position - Position for the new branching point : no effect if targetEnodeId provided
+   * @param targetEnodeId - if provided, the existing enode to split the wire at
+   * @returns Object containing the new branching point and an array of the two new wires
+   * @throws Error if wireId not found
+   */
+  splitWire(e, t, i = null) {
+    const n = this.wires.get(e);
+    if (!n)
+      throw new Error(`Wire ${e} does not exist`);
+    const s = this.enodes.get(n.node1), o = this.enodes.get(n.node2);
+    if (!s || !o)
+      throw new Error(`Wire ${e} is connected to non-existent ENodes`);
+    const a = [
+      s.getPosition(this),
+      ...n.intermediatePositions,
+      o.getPosition(this)
+    ], r = A(a, t), c = a.slice(1, r), l = a.slice(r, a.length - 1);
+    this.wires.delete(e), s.wires.delete(e), o.wires.delete(e);
+    let h;
+    if (i)
+      if (this.enodes.get(i))
+        h = this.enodes.get(i);
+      else
+        throw new Error(`Target ENode ${i} does not exist`);
+    else
+      h = this.addBranchingPoint(t);
+    const S = [];
+    if ((!h.component || s.component !== h.component) && !this.hasWireBetween(s.id, h.id)) {
+      const u = this.addWire(s.id, h.id, c);
+      u instanceof f ? (this.simplifyWireIntermediatePositions(u.id), S.push(u)) : console.warn(`Failure to create wire at split : ${u.message}`);
+    }
+    if ((!h.component || o.component !== h.component) && !this.hasWireBetween(o.id, h.id)) {
+      const u = this.addWire(h.id, o.id, l);
+      u instanceof f ? (this.simplifyWireIntermediatePositions(u.id), S.push(u)) : console.warn(`Failure to create wire at split : ${u.message}`);
+    }
+    return {
+      branchingPoint: h,
+      wires: S
+    };
+  }
+  getWireBetweenNodes(e, t) {
+    const i = this.enodes.get(e);
+    if (i)
+      for (const n of i.wires) {
+        const s = this.wires.get(n);
+        if (s && (s.node2 === t || s.node1 === t))
+          return s;
+      }
+  }
+  /**
+   * Get a wire by ID.
+   *
+   * @param id - Wire UUID
+   * @returns The Wire or undefined if not found
+   */
+  getWire(e) {
+    return this.wires.get(e);
+  }
+  /**
+   * Get all wires in the circuit.
+   *
+   * Returns a new array on each call (defensive copy).
+   *
+   * @returns Array of all Wires
+   */
+  getAllWires() {
+    return Array.from(this.wires.values());
+  }
+  /**
+   * Get all wires connected to a specific ENode.
+   *
+   * @param nodeId - ENode UUID
+   * @returns Array of connected Wires, or empty array if node not found
+   */
+  getWiresByNode(e) {
+    const t = this.enodes.get(e);
+    if (!t)
+      return [];
+    const i = [];
+    for (const n of t.wires) {
+      const s = this.wires.get(n);
+      s && i.push(s);
+    }
+    return i;
+  }
+  /**
+   * Get all wires connected to a component, e.g to any pin enode of the component.
+   *
+   * @param componentId - Component UUID
+   * @returns Array of connected Wires, or empty array if component not found
+   */
+  getWiresByComponent(e) {
+    const t = this.components.get(e);
+    if (!t)
+      return [];
+    const i = [];
+    for (const n of t.pins)
+      i.push(...this.getWiresByNode(n));
+    return i;
+  }
+  /**
+   * Get both ENodes connected by a wire.
+   *
+   * @param wireId - Wire UUID
+   * @returns Tuple [node1, node2] or undefined if wire not found
+   */
+  getNodesByWire(e) {
+    const t = this.wires.get(e);
+    if (!t)
+      return;
+    const i = this.enodes.get(t.node1), n = this.enodes.get(t.node2);
+    if (!(!i || !n))
+      return [i, n];
+  }
+  /**
+   * Check if a wire already exists between two nodes.
+   *
+   * Order-independent: returns true for (A, B) or (B, A).
+   *
+   * @param node1 - First ENode UUID
+   * @param node2 - Second ENode UUID
+   * @returns true if wire exists, false otherwise
+   */
+  hasWireBetween(e, t) {
+    const i = this.enodes.get(e);
+    if (!i)
+      return !1;
+    for (const n of i.wires) {
+      const s = this.wires.get(n);
+      if (s && (s.node2 === t || s.node1 === t))
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Find all components with pins among the provided enode IDs set.
+   *
+   * @param pinIds - Set of pins UUIDs
+   * @returns Set of components UUIDs
+   */
+  getComponentsOfPins(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (const i of e) {
+      const n = this.enodes.get(i);
+      n?.component && t.add(n.component);
+    }
+    return t;
+  }
+  /**
+   * Get a component's pin ENode by its label.
+   * @param component
+   * @param pinLabel
+   */
+  getComponentPinByLabel(e, t) {
+    let i = 0;
+    const n = L[e.type], s = Array.from(n.pins.keys());
+    for (const o of e.pins) {
+      const a = this.enodes.get(o), r = s[i];
+      if (r) {
+        if (a && r === t)
+          return a;
+        i++;
+      }
+    }
+  }
+  /**
+   * Update the intermediate positions of a wire.
+   * Update the wire in place.
+   *
+   * @param wireId - Wire to update
+   * @param intermediatePositions - New intermediate positions
+   * @param simplify - Whether to simplify positions by removing collinear points : useful when finalizing wire routing
+   * @returns The updated Wire
+   * @throws Error if wireId not found
+   */
+  updateWireIntermediatePositions(e, t, i = !1) {
+    const n = this.wires.get(e);
+    if (!n)
+      throw new Error(`Wire ${e} does not exist`);
+    if (i) {
+      const s = [
+        this.enodes.get(n.node1).getPosition(this),
+        ...t,
+        this.enodes.get(n.node2).getPosition(this)
+      ], o = E(s, 10);
+      n.intermediatePositions = o.slice(
+        1,
+        o.length - 1
+      );
+    } else
+      n.intermediatePositions = t;
+    return n;
+  }
+  /**
+   * Simplify intermediate positions of a wire.
+   * Update the wire in place.
+   * @param wireId - Wire to simplify
+   * @returns The updated Wire
+   * @throws Error if wireId not found
+   */
+  simplifyWireIntermediatePositions(e) {
+    const t = this.wires.get(e);
+    if (!t)
+      throw new Error(`Wire ${e} does not exist`);
+    const i = [
+      this.enodes.get(t.node1).getPosition(this),
+      ...t.intermediatePositions,
+      this.enodes.get(t.node2).getPosition(this)
+    ], n = E(i, 5);
+    return t.intermediatePositions = n.slice(
+      1,
+      n.length - 1
+    ), t.intermediatePositions = E(t.intermediatePositions), t;
+  }
+  /**
+   * Update the source type of an ENode (branching point or component pin).
+   * @param enodeId - ENode to update
+   * @param sourceType - New source type (null to clear)
+   * @throws Error if enodeId not found
+   */
+  updateENodeSourceType(e, t) {
+    const i = this.enodes.get(e);
+    if (!i)
+      throw new Error(`ENode ${e} does not exist`);
+    i.source = t || void 0;
+  }
+  /**
+   * iterate through all components, enodes and wires positions to get the size that allows to enclose all elements.
+   * @param margin - optional margin to add to the size
+   * @returns size that allows to enclose all elements plus margin
+   */
+  getEnclosingSize(e = 0) {
+    let t = 0;
+    for (const i of this.components.values())
+      t = Math.max(t, Math.abs(i.position.x), Math.abs(i.position.y));
+    for (const i of this.enodes.values()) {
+      if (i.type === g.Pin) continue;
+      const n = i.position;
+      n && (t = Math.max(t, Math.abs(n.x), Math.abs(n.y)));
+    }
+    for (const i of this.wires.values())
+      for (const n of i.intermediatePositions)
+        t = Math.max(t, Math.abs(n.x), Math.abs(n.y));
+    return Math.ceil(t * 2 + Math.max(e, 0));
+  }
+  /**
+   * Serialize circuit to JSON.
+   *
+   * @returns JSON-serializable object containing all components, enodes, and wires
+   *
+   * @example
+   * ```typescript
+   * const json = circuit.toJSON();
+   * localStorage.setItem('my-circuit', JSON.stringify(json));
+   * ```
+   */
+  toJSON() {
+    return {
+      metadata: this.metadata.toJSON(),
+      components: this.getAllComponents().map((e) => e.toJSON()),
+      enodes: this.getAllENodes().map((e) => e.toJSON()),
+      wires: this.getAllWires().map((e) => e.toJSON())
+    };
+  }
+  /**
+   * Deserialize circuit from JSON.
+   *
+   * @param json - Circuit data
+   * @returns Circuit instance
+   * @throws {Error} If JSON is invalid or violates invariants
+   *
+   * @example
+   * ```typescript
+   * const jsonStr = localStorage.getItem('my-circuit');
+   * const json = JSON.parse(jsonStr);
+   * const circuit = Circuit.fromJSON(json);
+   * ```
+   */
+  static fromJSON(e) {
+    const t = new O();
+    t.metadata = v.fromJSON(e.metadata);
+    for (const i of e.components) {
+      const n = C.fromJSON(
+        i
+      );
+      t.components.set(n.id, n);
+    }
+    for (const i of e.enodes) {
+      const n = w.fromJSON(
+        i
+      );
+      t.enodes.set(n.id, n);
+    }
+    if (e.wires)
+      for (const i of e.wires) {
+        const n = f.fromJSON(
+          i
+        );
+        t.wires.set(n.id, n);
+        const s = t.enodes.get(n.node1), o = t.enodes.get(n.node2);
+        s && s.wires.add(n.id), o && o.wires.add(n.id);
+      }
+    return t;
+  }
+}
+class Q {
+  behaviors;
+  /**
+   * Create a new empty behavior registry.
+   */
+  constructor() {
+    this.behaviors = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a behavior for a component type.
+   * Overwrites any existing behavior for the same type.
+   *
+   * @param behavior - The component behavior to register
+   * @throws TypeError if behavior is null/undefined or componentType is empty
+   * @returns The registry instance for chaining
+   */
+  register(e) {
+    if (!e)
+      throw new TypeError("Behavior cannot be null or undefined");
+    if (!e.componentType || e.componentType.trim() === "")
+      throw new TypeError("Behavior componentType cannot be empty");
+    return this.behaviors.set(e.componentType, e), this;
+  }
+  /**
+   * Register multiple behaviors at once.
+   * Convenience method for bulk registration.
+   *
+   * @param behaviors - Array of behaviors to register
+   */
+  registerAll(e) {
+    e.forEach((t) => this.register(t));
+  }
+  /**
+   * Get the behavior for a component type.
+   *
+   * @param componentType - Type identifier (e.g., "battery", "led")
+   * @returns The registered behavior, or undefined if not found
+   */
+  get(e) {
+    return this.behaviors.get(e);
+  }
+  /**
+   * Check if a behavior is registered for a component type.
+   *
+   * @param componentType - Type identifier to check
+   * @returns True if behavior is registered
+   */
+  has(e) {
+    return this.behaviors.has(e);
+  }
+  /**
+   * Unregister a behavior for a component type.
+   *
+   * @param componentType - Type identifier to unregister
+   * @returns True if behavior was found and removed
+   */
+  unregister(e) {
+    return this.behaviors.delete(e);
+  }
+  /**
+   * Clear all registered behaviors.
+   */
+  clear() {
+    this.behaviors.clear();
+  }
+  /**
+   * Get all registered component types.
+   *
+   * @returns Array of component type identifiers
+   */
+  getRegisteredTypes() {
+    return Array.from(this.behaviors.keys());
+  }
+  /**
+   * Get count of registered behaviors.
+   *
+   * @returns Number of registered behaviors
+   */
+  size() {
+    return this.behaviors.size;
+  }
+}
+class m {
+  /**
+   * Component UUID this state belongs to.
+   * @readonly
+   */
+  componentId;
+  /**
+   * Current operational state (varies by component type).
+   * Examples: "on", "off", "open", "closed", "activating", "active"
+   */
+  state;
+  /**
+   * Tick when this state started.
+   */
+  startTick;
+  /**
+   * Create a new component state.
+   *
+   * @param componentId - UUID of the component
+   * @param initialState - Initial operational state
+   */
+  constructor(e, t) {
+    this.componentId = e, this.state = t, this.startTick = 0;
+  }
+  hasSameComponent(e) {
+    return this.componentId === e.componentId;
+  }
+}
+class B extends m {
+  /**
+   * Create a new battery state.
+   *
+   * @param componentId - UUID of the battery component
+   */
+  constructor(e) {
+    super(e, "on");
+  }
+}
+class k {
+  componentType = p.Battery;
+  /**
+   * Create initial state for a battery.
+   *
+   * @param component - The Battery component
+   * @returns Battery Initial state (always active and delivering voltage)
+   */
+  createInitialState(e) {
+    if (e.type !== p.Battery)
+      throw new Error(`Invalid component type for BatteryBehavior: ${e.type}`);
+    return new B(e.id);
+  }
+  allowConductivity(e, t, i, n, s) {
+    return !1;
+  }
+  /**
+   * Batteries are always on, and their pins are locked so this is more of a decorative function
+   * @param component
+   * @param componentState
+   * @param nodeStates
+   * @param _targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const o in e.pins)
+      s.set(e.getPinLabel(o), i.get(o));
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onUserCommand(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+}
+class W extends m {
+  /**
+   * Create a new Lightbulb state.
+   *
+   * @param componentId - UUID of the Lightbulb component
+   * @param initialState - Initial operational state (default: "off")
+   */
+  constructor(e, t = "off") {
+    super(e, t);
+  }
+  /**
+   * Check if Lightbulb is in lit state (on or going_on)
+   */
+  get isLit() {
+    return this.state === "on" || this.state === "goingOn";
+  }
+}
+class x {
+  componentType = p.Lightbulb;
+  /**
+   * Create initial state for a lightbulb.
+   *
+   * @param component - The lightbulb component
+   * @returns lightbulbInitial state (always active and delivering voltage)
+   */
+  createInitialState(e) {
+    if (e.type !== p.Lightbulb)
+      throw new Error(`Invalid component type for lightbulbBehavior: ${e.type}`);
+    return new W(e.id);
+  }
+  allowConductivity(e, t, i, n, s) {
+    return !0;
+  }
+  /**
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const c of e.pins)
+      s.set(e.getPinLabel(c), i.get(c));
+    let o = s.get("pin1").hasVoltage && s.get("pin1").hasCurrent || s.get("pin2").hasVoltage && s.get("pin2").hasCurrent || s.get("pin1").hasVoltage && s.get("pin2").hasCurrent || s.get("pin2").hasVoltage && s.get("pin1").hasCurrent, a = !1;
+    const r = [];
+    return o ? (t.state === "off" || t.state === "goingOff") && (a = !0, t.state = "goingOn", t.startTick = n, r.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + 1,
+      // TODO handle component config later
+      type: "GoingOnEnd",
+      parameters: void 0
+    }), t.state = "goingOn") : (t.state === "on" || t.state === "goingOn") && (a = !0, t.state = "goingOff", t.startTick = n, r.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + 1,
+      // TODO handle component config later
+      type: "GoingOffEnd",
+      parameters: void 0
+    }), t.state = "goingOff"), {
+      componentState: t,
+      hasChanged: a,
+      scheduledEvents: r
+    };
+  }
+  onUserCommand(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, i) {
+    let n = !1;
+    return i.type === "GoingOffEnd" ? t.state !== "off" && (n = !0, t.startTick = i.readyAtTick, t.state = "off") : i.type === "GoingOnEnd" && t.state !== "on" && (n = !0, t.startTick = i.readyAtTick, t.state = "on"), {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: []
+    };
+  }
+}
+class N extends m {
+  /**
+   * Create a new SmallLED state.
+   *
+   * @param componentId - UUID of the LED component
+   * @param initialState - Initial operational state (default: "off")
+   */
+  constructor(e, t = "off") {
+    super(e, t);
+  }
+  /**
+   * Check if LED is in lit state (on or going_on)
+   */
+  get isLit() {
+    return this.state === "on" || this.state === "goingOn";
+  }
+}
+class I {
+  componentType = p.SmallLED;
+  /**
+   * Create initial state for a smallLED.
+   *
+   * @param component - The smallLED component
+   * @returns LED Initial state (always active and delivering voltage)
+   */
+  createInitialState(e) {
+    if (e.type !== p.SmallLED)
+      throw new Error(`Invalid component type for SmallLEDBehavior: ${e.type}`);
+    return new N(e.id);
+  }
+  allowConductivity(e, t, i, n, s) {
+    return !0;
+  }
+  /**
+   * only symmetrical behavior of LEDS is handled for now
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const c of e.pins)
+      s.set(e.getPinLabel(c), i.get(c));
+    let o = s.get("anode").hasVoltage && s.get("anode").hasCurrent || s.get("cathode").hasVoltage && s.get("cathode").hasCurrent || s.get("anode").hasVoltage && s.get("cathode").hasCurrent || s.get("cathode").hasVoltage && s.get("anode").hasCurrent, a = !1;
+    const r = [];
+    return o ? (t.state === "off" || t.state === "goingOff") && (a = !0, t.state = "goingOn", t.startTick = n, r.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + 1,
+      // TODO handle component config later
+      type: "GoingOnEnd",
+      parameters: void 0
+    })) : (t.state === "on" || t.state === "goingOn") && (a = !0, t.state = "goingOff", t.startTick = n, r.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + 1,
+      // TODO handle component config later
+      type: "GoingOffEnd",
+      parameters: void 0
+    })), {
+      componentState: t,
+      hasChanged: a,
+      scheduledEvents: r
+    };
+  }
+  onUserCommand(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, i) {
+    let n = !1;
+    return i.type === "GoingOffEnd" ? t.state !== "off" && (n = !0, t.startTick = i.readyAtTick, t.state = "off") : i.type === "GoingOnEnd" && t.state !== "on" && (n = !0, t.startTick = i.readyAtTick, t.state = "on"), {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: []
+    };
+  }
+}
+class $ extends N {
+}
+class M extends I {
+  componentType = p.RectangleLED;
+  /**
+   * Create initial state for a RectangleLED.
+   *
+   * @param component - The smallLED component
+   * @returns LED Initial state (always active and delivering voltage)
+   */
+  createInitialState(e) {
+    if (e.type !== p.RectangleLED)
+      throw new Error(`Invalid component type for RectangleLEDBehavior: ${e.type}`);
+    return new $(e.id);
+  }
+}
+class J extends m {
+  /**
+   * Create a new Relay state.
+   *
+   * @param componentId - UUID of the Relay component
+   * @param initialState - Initial operational state (default: "open")
+   */
+  constructor(e, t = "open") {
+    super(e, t);
+  }
+  /**
+   * Check if relay is in opening or closing state
+   */
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
+  }
+  /**
+   * Check if relay is in closed or closing state
+   */
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
+  }
+}
+function D(d) {
+  const e = parseInt(d.get("transitionSpan") || "", 10);
+  return isNaN(e) || e < 1 ? y.TRANSITION_SPAN_TICKS : e;
+}
+class R {
+  componentType = p.Relay;
+  /**
+   * Create initial state for a relay.
+   *
+   * @param component - The Relay component
+   * @returns Relay Initial state (open by default)
+   */
+  createInitialState(e) {
+    if (e.type !== p.Relay)
+      throw new Error(`Invalid component type for RelayBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "closed" : "open";
+    return new J(e.id, t);
+  }
+  allowConductivity(e, t, i, n, s) {
+    if (n === s) return !0;
+    const o = e.getPinLabel(n), a = e.getPinLabel(s);
+    if (!o || !a) return !1;
+    const r = [o, a];
+    return r.includes("cmd_in") && r.includes("cmd_out") ? !0 : r.includes("power_in") && r.includes("power_out") ? t.state === "closed" || t.state === "opening" : !1;
+  }
+  /**
+   * Relay cmd pins need to have voltage and current so that relay contactor stays closed
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const h of e.pins)
+      s.set(e.getPinLabel(h), i.get(h));
+    const o = s.get("cmd_in").hasVoltage && s.get("cmd_in").hasCurrent || s.get("cmd_out").hasVoltage && s.get("cmd_out").hasCurrent || s.get("cmd_in").hasVoltage && s.get("cmd_out").hasCurrent || s.get("cmd_out").hasVoltage && s.get("cmd_in").hasCurrent, a = e.config.get("activationLogic") === "negative" ? !o : o;
+    let r = !1;
+    const c = [], l = D(e.config);
+    return a ? (t.state === "open" || t.state === "opening") && (r = !0, t.state = "closing", t.startTick = n, c.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + l,
+      type: "ClosingEnd",
+      parameters: void 0
+    })) : (t.state === "closed" || t.state === "closing") && (r = !0, t.state = "opening", t.startTick = n, c.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + l,
+      type: "OpeningEnd",
+      parameters: void 0
+    })), {
+      componentState: t,
+      hasChanged: r,
+      scheduledEvents: c
+    };
+  }
+  onUserCommand(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, i) {
+    let n = !1;
+    return i.type === "ClosingEnd" ? t.state !== "closed" && (n = !0, t.startTick = i.readyAtTick, t.state = "closed") : i.type === "OpeningEnd" && t.state !== "open" && (n = !0, t.startTick = i.readyAtTick, t.state = "open"), {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: []
+    };
+  }
+}
+class F extends m {
+  /**
+   * Create a new Switch state.
+   *
+   * @param componentId - UUID of the Switch component
+   * @param initialState - Initial operational state (default: "open")
+   */
+  constructor(e, t = "open") {
+    super(e, t);
+  }
+  /**
+   * Check if switch is in opening or closing state
+   */
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
+  }
+  /**
+   * Check if switch is in closed or closing state
+   */
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
+  }
+}
+class V extends m {
+  /**
+   * Create a new Transistor state.
+   *
+   * @param componentId - UUID of the Transistor component
+   * @param initialState - Initial operational state (default: "open")
+   */
+  constructor(e, t = "open") {
+    super(e, t);
+  }
+  /**
+   * Check if transistor is in opening or closing state
+   */
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
+  }
+  /**
+   * Check if transistor is in closed or closing state
+   */
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
+  }
+}
+function U(d) {
+  if (!d)
+    return y.TRANSITION_SPAN_TICKS;
+  const e = parseInt(d.get("tickCount") || "", 10);
+  return isNaN(e) || e < 1 ? y.TRANSITION_SPAN_TICKS : e;
+}
+class z {
+  componentType = p.Switch;
+  /**
+   * Create initial state for a switch.
+   *
+   * @param component - The Switch component
+   * @returns Switch Initial state (open by default)
+   */
+  createInitialState(e) {
+    if (e.type !== p.Switch)
+      throw new Error(`Invalid component type for SwitchBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "open";
+    return new F(e.id, t);
+  }
+  allowConductivity(e, t, i, n, s) {
+    return t.state === "closed" || t.state === "opening";
+  }
+  /**
+   * Switches states depend on user interaction, not their pins so this is more of a decorative function
+   * @param _component
+   * @param componentState
+   * @param _nodeStates
+   * @param _targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onUserCommand(e, t, i) {
+    let n = !1;
+    const s = [];
+    if (i.type === "toggle_switch" && ["open", "closed"].includes(t.state)) {
+      t.state = t.state === "open" ? "closing" : "opening", t.startTick = i.scheduledAtTick + 1, n = !0;
+      const o = U(i.parameters);
+      s.push({
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.startTick + o,
+        type: t.state === "closing" ? "ClosingEnd" : "OpeningEnd",
+        parameters: void 0
+      });
+    }
+    return {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: s
+    };
+  }
+  onEventFiring(e, t, i) {
+    let n = !1;
+    return i.type === "ClosingEnd" ? t.state !== "closed" && (n = !0, t.startTick = i.readyAtTick, t.state = "closed") : i.type === "OpeningEnd" && t.state !== "open" && (n = !0, t.startTick = i.readyAtTick, t.state = "open"), {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: []
+    };
+  }
+}
+function G(d) {
+  const e = parseInt(d.get("transitionSpan") || "", 10);
+  return isNaN(e) || e < 1 ? y.TRANSITION_SPAN_TICKS : e;
+}
+class K {
+  componentType = p.Transistor;
+  /**
+   * Create initial state for a transistor.
+   *
+   * @param component - The Transistor component
+   * @returns Transistor Initial state (open by default)
+   */
+  createInitialState(e) {
+    if (e.type !== p.Transistor)
+      throw new Error(`Invalid component type for TransistorBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "closed" : "open";
+    return new V(e.id, t);
+  }
+  allowConductivity(e, t, i, n, s) {
+    if (n === s) return !0;
+    const o = e.getPinLabel(n), a = e.getPinLabel(s);
+    if (!o || !a) return !1;
+    const r = [o, a];
+    return r.includes("collector") && r.includes("emitter") ? t.state === "closed" || t.state === "opening" : !1;
+  }
+  /**
+   * Transistor Base need to have only voltage so that transistor contactor stays closed
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
+   */
+  onPinsChange(e, t, i, n) {
+    const s = /* @__PURE__ */ new Map();
+    for (const h of e.pins)
+      s.set(e.getPinLabel(h), i.get(h));
+    const o = s.get("base").hasVoltage, a = e.config.get("activationLogic") === "negative" ? !o : o;
+    let r = !1;
+    const c = [], l = G(e.config);
+    return a ? (t.state === "open" || t.state === "opening") && (r = !0, t.state = "closing", t.startTick = n, c.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + l,
+      type: "ClosingEnd",
+      parameters: void 0
+    })) : (t.state === "closed" || t.state === "closing") && (r = !0, t.state = "opening", t.startTick = n, c.push({
+      targetId: e.id,
+      scheduledAtTick: n,
+      readyAtTick: n + l,
+      type: "OpeningEnd",
+      parameters: void 0
+    })), {
+      componentState: t,
+      hasChanged: r,
+      scheduledEvents: c
+    };
+  }
+  onUserCommand(e, t, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, i) {
+    let n = !1;
+    return i.type === "ClosingEnd" ? t.state !== "closed" && (n = !0, t.startTick = i.readyAtTick, t.state = "closed") : i.type === "OpeningEnd" && t.state !== "open" && (n = !0, t.startTick = i.readyAtTick, t.state = "open"), {
+      componentState: t,
+      hasChanged: n,
+      scheduledEvents: []
+    };
+  }
+}
+function Y(d) {
+  d.register(new k()).register(new x()).register(new M()).register(new R()).register(new I()).register(new z()).register(new K());
+}
+export {
+  k as BatteryBehavior,
+  B as BatteryState,
+  Q as BehaviorRegistry,
+  L as COMPONENT_TYPE_METADATA,
+  b as CameraOptions,
+  O as Circuit,
+  v as CircuitMetadata,
+  Z as CircuitRunner,
+  C as Component,
+  m as ComponentState,
+  p as ComponentType,
+  j as DirtyTracker,
+  w as ENode,
+  ee as ENodeSourceType,
+  g as ENodeType,
+  te as EventQueue,
+  x as LightbulbBehavior,
+  W as LightbulbState,
+  P as Position,
+  ne as Position3D,
+  M as RectangleLEDBehavior,
+  $ as RectangleLEDState,
+  R as RelayBehavior,
+  J as RelayState,
+  ie as Rotation,
+  se as SIMULATION_SPEED,
+  oe as SimulationState,
+  I as SmallLEDBehavior,
+  N as SmallLEDState,
+  re as StateManager,
+  z as SwitchBehavior,
+  F as SwitchState,
+  y as TRANSITION_DEFAULTS,
+  K as TransistorBehavior,
+  V as TransistorState,
+  f as Wire,
+  A as findPositionBestIndex,
+  T as generateUUID,
+  ae as getAllComponentTypes,
+  _ as getComponentTypeMetadata,
+  Y as registerBasicComponentsBehaviors,
+  E as simplifyPositions
+};
+//# sourceMappingURL=index.js.map