simple-circuit-engine 0.0.9 → 0.0.11

package/dist/core/index.js

@@ -1,208 +1,58 @@
-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-FXM_s5ll.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-FXM_s5ll.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,
+import { g as M, P as R, D as O, b as E, C as A, c as h, d as G, i as _, h as I, e as m, f as D, s as P, T as S } from "../CircuitRunner-BQQlhwjD.js";
+import { A as Me, m as Re, k as De, E as We, j as ke, a as Fe, R as Xe, S as Je, n as Ue, l as ze } from "../CircuitRunner-BQQlhwjD.js";
+function W(a) {
+  let e, t, o;
+  return typeof a == "object" ? (e = a.hashFunction, t = a.expiring, o = a.tags) : e = a, (i, n, s) => {
+    if (s.value != null)
+      s.value = b(s.value, e, t, o);
+    else if (s.get != null)
+      s.get = b(s.get, e, t, o);
+    else
+      throw "Only put a Memoize() decorator on a method or get accessor.";
+  };
+}
+function be(a, e) {
+  return W({
+    expiring: a,
+    hashFunction: e
+  });
+}
+const T = /* @__PURE__ */ new Map();
+function b(a, e, t = 0, o) {
+  const i = Symbol("__memoized_map__");
+  return function(...n) {
+    let s;
+    this.hasOwnProperty(i) || Object.defineProperty(this, i, {
+      configurable: !1,
+      enumerable: !1,
       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
+      value: /* @__PURE__ */ new Map()
     });
-  }
-  /**
-   * 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;
-  }
+    let c = this[i];
+    if (Array.isArray(o))
+      for (const r of o)
+        T.has(r) ? T.get(r).push(c) : T.set(r, [c]);
+    if (e || n.length > 0 || t > 0) {
+      let r;
+      e === !0 ? r = n.map((l) => l.toString()).join("!") : e ? r = e.apply(this, n) : r = n[0];
+      const u = `${r}__timestamp`;
+      let d = !1;
+      if (t > 0)
+        if (!c.has(u))
+          d = !0;
+        else {
+          let l = c.get(u);
+          d = Date.now() - l > t;
+        }
+      c.has(r) && !d ? s = c.get(r) : (s = a.apply(this, n), c.set(r, s), t > 0 && c.set(u, Date.now()));
+    } else {
+      const r = this;
+      c.has(r) ? s = c.get(r) : (s = a.apply(this, n), c.set(r, s));
+    }
+    return s;
+  };
 }
-class f {
+class w {
   /**
    * Unique identifier for this wire.
    * @readonly
@@ -248,8 +98,8 @@ class f {
    * );
    * ```
    */
-  constructor(e, t, i = []) {
-    this.id = T(), this.node1 = e, this.node2 = t, this.intermediatePositions = i;
+  constructor(e, t, o = []) {
+    this.id = M(), this.node1 = e, this.node2 = t, this.intermediatePositions = o;
   }
   /**
    * Check if this is a straight-line wire.
@@ -312,52 +162,169 @@ class f {
    * ```
    */
   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", {
+    const t = e.intermediatePositions.map((i) => R.fromJSON(i)), o = new w(e.node1, e.node2, t);
+    return Object.defineProperty(o, "id", {
       value: e.id,
       writable: !1,
       enumerable: !0,
       configurable: !1
-    }), i;
+    }), o;
   }
 }
-class v {
+class C {
+  /**
+   * Create new circuit options.
+   *
+   * @param name - Circuit name (default: Untitled Circuit)
+   * @param defaultLogicFamily - Circuit default logic family (default: CMOS1)
+   */
+  constructor(e = "Untitled Circuit", t = O) {
+    this.name = e, this.defaultLogicFamily = t;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      defaultLogicFamily: this.defaultLogicFamily
+    };
+  }
+  static fromJSON(e) {
+    return new C(e.name, e.defaultLogicFamily);
+  }
+}
+class N {
   /**
    * Create a new CircuitMetadata holding general information about the Circuit.
    *
-   * @param name - Name of the circuit
+   * @param version - Circuit version
+   * @param options - Circuit options
    * @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))
+  constructor(e, t, o, i, n) {
+    if (this.version = e, this.options = t, this.size = o, this.divisions = i, this.cameraOptions = n, !Number.isInteger(o) || !Number.isInteger(i))
       throw new TypeError(
-        `Size and divisions must be integers (got size=${t}, divisions=${i})`
+        `Size and divisions must be integers (got size=${o}, divisions=${i})`
       );
   }
   toJSON() {
     return {
-      name: this.name,
+      version: this.version,
+      options: this.options.toJSON(),
       size: this.size,
       divisions: this.divisions,
       cameraOptions: this.cameraOptions.toJSON()
     };
   }
   static fromJSON(e) {
-    return new v(
-      e.name,
+    E !== e.version && console.warn(`This version of the engine supports v${E} circuit version files. 
+      Unexpected behavior may occurs loading v${e.version}.`);
+    const t = e.options ? C.fromJSON(e.options) : new C("Untitled Circuit", O);
+    return new N(
+      e.version,
+      t,
       e.size,
       e.divisions,
-      b.fromJSON(e.cameraOptions)
+      A.fromJSON(e.cameraOptions)
     );
   }
   toString() {
-    return `CircuitMetadata(${this.name}, ${this.size}, ${this.divisions}, ${this.cameraOptions.toString()})`;
+    return `CircuitMetadata(${this.version}, ${this.options.name}, ${this.options.defaultLogicFamily}, ${this.size}, ${this.divisions}, ${this.cameraOptions.toString()})`;
+  }
+}
+const k = { 2: 1, 4: 1, 8: 2, 16: 2 }, F = { 2: 2, 4: 2, 8: 3, 16: 3 }, X = { 2: 1, 4: 2, 8: 2, 16: 3 }, J = { 2: 2, 4: 3, 8: 3, 16: 4 };
+function U(a) {
+  const e = a.config.get("defaultLogicFamily");
+  if (!(!e || e === "Sandbox") && z(a.type)) {
+    const t = a.config.get("activationLogic") ?? "negative", o = H(a.type, t);
+    return o && K(e, o.gateFamily, o.inputCount) || void 0;
+  }
+}
+function z(a) {
+  return [
+    h.Inverter,
+    h.NandGate,
+    h.Nand4Gate,
+    h.Nand8Gate,
+    h.NorGate,
+    h.Nor4Gate,
+    h.Nor8Gate,
+    h.XorGate,
+    h.Xor4Gate,
+    h.Xor8Gate
+  ].includes(a);
+}
+function H(a, e) {
+  switch (a) {
+    case h.Inverter:
+      return { gateFamily: e === "negative" ? "NOT" : "Buffer", inputCount: 1 };
+    case h.NandGate:
+      return { gateFamily: e === "negative" ? "NAND" : "AND", inputCount: 2 };
+    case h.Nand4Gate:
+      return { gateFamily: e === "negative" ? "NAND" : "AND", inputCount: 4 };
+    case h.Nand8Gate:
+      return { gateFamily: e === "negative" ? "NAND" : "AND", inputCount: 8 };
+    case h.NorGate:
+      return { gateFamily: e === "negative" ? "NOR" : "OR", inputCount: 2 };
+    case h.Nor4Gate:
+      return { gateFamily: e === "negative" ? "NOR" : "OR", inputCount: 4 };
+    case h.Nor8Gate:
+      return { gateFamily: e === "negative" ? "NOR" : "OR", inputCount: 8 };
+    case h.XorGate:
+      return { gateFamily: e === "negative" ? "XNOR" : "XOR", inputCount: 2 };
+    case h.Xor4Gate:
+      return { gateFamily: e === "negative" ? "XNOR" : "XOR", inputCount: 4 };
+    case h.Xor8Gate:
+      return { gateFamily: e === "negative" ? "XNOR" : "XOR", inputCount: 8 };
+    default:
+      return null;
+  }
+}
+function K(a, e, t) {
+  if (a === "Sandbox")
+    throw new Error("computeGateDelay must not be called for Sandbox family");
+  if (e === "NOT") return 1;
+  if (e === "Buffer") return 2;
+  if (e === "XOR") return Math.log2(t) * 2;
+  if (e === "XNOR") return Math.log2(t) * 2 + 1;
+  if (a === "CMOS1") {
+    const o = Math.log2(t);
+    switch (e) {
+      case "NAND":
+        return o;
+      case "NOR":
+        return o;
+      case "AND":
+        return o + 1;
+      case "OR":
+        return o + 1;
+    }
   }
+  if (a === "TTL1") {
+    let o;
+    switch (e) {
+      case "NAND":
+        o = k;
+        break;
+      case "AND":
+        o = F;
+        break;
+      case "NOR":
+        o = X;
+        break;
+      case "OR":
+        o = J;
+        break;
+    }
+    const i = o[t];
+    if (i === void 0)
+      throw new Error(`Unsupported input count ${t} for TTL1 ${e}`);
+    return i;
+  }
+  throw new Error(`Unsupported logic family: ${a}`);
 }
-class O {
+class x {
   /**
    * Circuit metadata holding general information.
    * @private
@@ -382,16 +349,16 @@ class O {
   /**
    * 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();
+  constructor(e) {
+    this.metadata = new N(E, e, 10, 10, new A()), this.components = /* @__PURE__ */ new Map(), this.enodes = /* @__PURE__ */ new Map(), this.wires = /* @__PURE__ */ new Map();
   }
   get name() {
-    return this.metadata.name;
+    return this.metadata.options.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;
+    this.metadata.options.name = e;
   }
   /**
    * Add a new component to the circuit.
@@ -420,27 +387,43 @@ class O {
    * 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,
+  addComponent(e, t, o, i) {
+    const n = G[e], s = new _(e, t, o, []);
+    if (i)
+      for (const [r, u] of i)
+        s.config.set(r, u);
+    s.config.has("defaultLogicFamily") && !s.config.get("defaultLogicFamily") && s.config.set("defaultLogicFamily", this.metadata.options.defaultLogicFamily), this.resolveTransitionSpan(s);
+    const c = [];
+    for (const [r, u] of n.pins) {
+      const d = new I(
+        m.Pin,
+        s.id,
         r,
         void 0,
-        // Pin position derived from component,
-        c
+        // Pin position derived from component
+        u.sourceType,
+        u.subtype
       );
-      this.enodes.set(l.id, l), a.push(l.id);
+      this.enodes.set(d.id, d), c.push(d.id);
     }
-    return Object.defineProperty(o, "pins", {
-      value: a,
+    return Object.defineProperty(s, "pins", {
+      value: c,
       writable: !1,
       enumerable: !0,
       configurable: !1
-    }), this.components.set(o.id, o), o;
+    }), this.components.set(s.id, s), s;
+  }
+  /**
+   * Resolve and update the transitionSpan config for a component
+   * if automatic resolution returns undefined nothing is done on the component
+   *
+   * @param component - Component to resolve transitionSpan for
+   */
+  resolveTransitionSpan(e) {
+    if (!e.config.has("transitionSpan"))
+      return;
+    const t = U(e);
+    t && e.config.set("transitionSpan", String(t));
   }
   /**
    * Remove a component from the circuit.
@@ -463,17 +446,17 @@ class O {
     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);
+    const o = [], i = [];
+    for (const n of t.pins) {
+      const s = this.enodes.get(n);
+      if (s) {
+        const c = Array.from(s.wires);
+        for (const r of c)
+          this.removeWire(r), o.push(r);
       }
-      this.enodes.delete(s), n.push(s);
+      this.enodes.delete(n), i.push(n);
     }
-    return this.components.delete(e), { deletedWires: i, deletedENodes: n };
+    return this.components.delete(e), { deletedWires: o, deletedENodes: i };
   }
   hasComponent(e) {
     return this.components.has(e);
@@ -517,8 +500,8 @@ class O {
   }
   getAllComponentsByType(e) {
     const t = [];
-    for (const i of this.components.values())
-      i.type === e && t.push(i);
+    for (const o of this.components.values())
+      o.type === e && t.push(o);
     return t;
   }
   getFirstComponentOfType(e) {
@@ -583,14 +566,14 @@ class O {
    * @returns The created ENode
    */
   addBranchingPoint(e, t) {
-    const i = new w(
-      g.BranchingPoint,
+    const o = new I(
+      m.BranchingPoint,
       void 0,
       void 0,
       e,
       t
     );
-    return this.enodes.set(i.id, i), i;
+    return this.enodes.set(o.id, o), o;
   }
   /**
    * Remove a branching point electrical node from the circuit.
@@ -604,25 +587,25 @@ class O {
     const t = this.enodes.get(e);
     if (!t)
       throw new Error(`Enode ${e} does not exist`);
-    if (t.type !== g.BranchingPoint)
+    if (t.type !== m.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 });
+    const o = {}, i = this.getWiresByNode(e);
+    if (i.length === 1 || i.length > 2) {
+      const n = [];
+      for (const s of i)
+        this.removeWire(s.id), n.push(s.id);
+      Object.assign(o, { deletedWires: n });
+    } else if (i.length === 2) {
+      const n = i[0], s = i[1], c = n.node1 === e ? n.node2 : n.node1, r = s.node1 === e ? s.node2 : s.node1, u = [];
+      c === n.node1 ? u.push(...n.intermediatePositions) : c === n.node2 && u.push(...[...n.intermediatePositions].reverse()), u.push(t.getPosition(this)), r === s.node1 ? u.push(...[...s.intermediatePositions].reverse()) : r === s.node2 && u.push(...s.intermediatePositions), this.removeWire(n.id), this.removeWire(s.id);
+      const d = this.addWire(c, r, u);
+      if (d instanceof Error)
+        throw new Error(`Failed to merge wires at branching point ${e}: ${d.message}`);
+      Object.assign(o, { mergedWires: [n.id, s.id] }), Object.assign(o, { newWire: d });
     }
-    return this.enodes.delete(e), i;
+    return this.enodes.delete(e), o;
   }
   /**
    * Add a wire connecting two electrical nodes.
@@ -646,16 +629,16 @@ class O {
    * }
    * ```
    */
-  addWire(e, t, i) {
+  addWire(e, t, o) {
     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)
+    const i = this.enodes.get(e), n = this.enodes.get(t);
+    if (!i || !n)
       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;
+    const s = new w(e, t, o || []);
+    return this.wires.set(s.id, s), i.wires.add(s.id), n.wires.add(s.id), s;
   }
   /**
    * Remove a wire from the circuit.
@@ -673,8 +656,8 @@ class O {
     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);
+    const o = this.enodes.get(t.node1), i = this.enodes.get(t.node2);
+    o && o.wires.delete(e), i && i.wires.delete(e), this.wires.delete(e);
   }
   /**
    * Split a wire in the circuit.
@@ -705,48 +688,48 @@ class O {
    * @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)
+  splitWire(e, t, o = null) {
+    const i = this.wires.get(e);
+    if (!i)
       throw new Error(`Wire ${e} does not exist`);
-    const s = this.enodes.get(n.node1), o = this.enodes.get(n.node2);
-    if (!s || !o)
+    const n = this.enodes.get(i.node1), s = this.enodes.get(i.node2);
+    if (!n || !s)
       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);
+    const c = [
+      n.getPosition(this),
+      ...i.intermediatePositions,
+      s.getPosition(this)
+    ], r = D(c, t), u = c.slice(1, r), d = c.slice(r, c.length - 1);
+    this.wires.delete(e), n.wires.delete(e), s.wires.delete(e);
+    let l;
+    if (o)
+      if (this.enodes.get(o))
+        l = this.enodes.get(o);
       else
-        throw new Error(`Target ENode ${i} does not exist`);
+        throw new Error(`Target ENode ${o} 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}`);
+      l = this.addBranchingPoint(t);
+    const B = [];
+    if ((!l.component || n.component !== l.component) && !this.hasWireBetween(n.id, l.id)) {
+      const f = this.addWire(n.id, l.id, u);
+      f instanceof w ? (this.simplifyWireIntermediatePositions(f.id), B.push(f)) : console.warn(`Failure to create wire at split : ${f.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}`);
+    if ((!l.component || s.component !== l.component) && !this.hasWireBetween(s.id, l.id)) {
+      const f = this.addWire(l.id, s.id, d);
+      f instanceof w ? (this.simplifyWireIntermediatePositions(f.id), B.push(f)) : console.warn(`Failure to create wire at split : ${f.message}`);
     }
     return {
-      branchingPoint: h,
-      wires: S
+      branchingPoint: l,
+      wires: B
     };
   }
   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;
+    const o = this.enodes.get(e);
+    if (o)
+      for (const i of o.wires) {
+        const n = this.wires.get(i);
+        if (n && (n.node2 === t || n.node1 === t))
+          return n;
       }
   }
   /**
@@ -778,12 +761,12 @@ class O {
     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);
+    const o = [];
+    for (const i of t.wires) {
+      const n = this.wires.get(i);
+      n && o.push(n);
     }
-    return i;
+    return o;
   }
   /**
    * Get all wires connected to a component, e.g to any pin enode of the component.
@@ -795,10 +778,10 @@ class O {
     const t = this.components.get(e);
     if (!t)
       return [];
-    const i = [];
-    for (const n of t.pins)
-      i.push(...this.getWiresByNode(n));
-    return i;
+    const o = [];
+    for (const i of t.pins)
+      o.push(...this.getWiresByNode(i));
+    return o;
   }
   /**
    * Get both ENodes connected by a wire.
@@ -810,9 +793,9 @@ class O {
     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];
+    const o = this.enodes.get(t.node1), i = this.enodes.get(t.node2);
+    if (!(!o || !i))
+      return [o, i];
   }
   /**
    * Check if a wire already exists between two nodes.
@@ -824,12 +807,12 @@ class O {
    * @returns true if wire exists, false otherwise
    */
   hasWireBetween(e, t) {
-    const i = this.enodes.get(e);
-    if (!i)
+    const o = this.enodes.get(e);
+    if (!o)
       return !1;
-    for (const n of i.wires) {
-      const s = this.wires.get(n);
-      if (s && (s.node2 === t || s.node1 === t))
+    for (const i of o.wires) {
+      const n = this.wires.get(i);
+      if (n && (n.node2 === t || n.node1 === t))
         return !0;
     }
     return !1;
@@ -842,9 +825,9 @@ class O {
    */
   getComponentsOfPins(e) {
     const t = /* @__PURE__ */ new Set();
-    for (const i of e) {
-      const n = this.enodes.get(i);
-      n?.component && t.add(n.component);
+    for (const o of e) {
+      const i = this.enodes.get(o);
+      i?.component && t.add(i.component);
     }
     return t;
   }
@@ -854,14 +837,14 @@ class O {
    * @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];
+    let o = 0;
+    const i = G[e.type], n = Array.from(i.pins.keys());
+    for (const s of e.pins) {
+      const c = this.enodes.get(s), r = n[o];
       if (r) {
-        if (a && r === t)
-          return a;
-        i++;
+        if (c && r === t)
+          return c;
+        o++;
       }
     }
   }
@@ -875,23 +858,23 @@ class O {
    * @returns The updated Wire
    * @throws Error if wireId not found
    */
-  updateWireIntermediatePositions(e, t, i = !1) {
-    const n = this.wires.get(e);
-    if (!n)
+  updateWireIntermediatePositions(e, t, o = !1) {
+    const i = this.wires.get(e);
+    if (!i)
       throw new Error(`Wire ${e} does not exist`);
-    if (i) {
-      const s = [
-        this.enodes.get(n.node1).getPosition(this),
+    if (o) {
+      const n = [
+        this.enodes.get(i.node1).getPosition(this),
         ...t,
-        this.enodes.get(n.node2).getPosition(this)
-      ], o = E(s, 10);
-      n.intermediatePositions = o.slice(
+        this.enodes.get(i.node2).getPosition(this)
+      ], s = P(n, 10);
+      i.intermediatePositions = s.slice(
         1,
-        o.length - 1
+        s.length - 1
       );
     } else
-      n.intermediatePositions = t;
-    return n;
+      i.intermediatePositions = t;
+    return i;
   }
   /**
    * Simplify intermediate positions of a wire.
@@ -904,15 +887,15 @@ class O {
     const t = this.wires.get(e);
     if (!t)
       throw new Error(`Wire ${e} does not exist`);
-    const i = [
+    const o = [
       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(
+    ], i = P(o, 5);
+    return t.intermediatePositions = i.slice(
       1,
-      n.length - 1
-    ), t.intermediatePositions = E(t.intermediatePositions), t;
+      i.length - 1
+    ), t.intermediatePositions = P(t.intermediatePositions), t;
   }
   /**
    * Update the source type of an ENode (branching point or component pin).
@@ -921,28 +904,29 @@ class O {
    * @throws Error if enodeId not found
    */
   updateENodeSourceType(e, t) {
-    const i = this.enodes.get(e);
-    if (!i)
+    const o = this.enodes.get(e);
+    if (!o)
       throw new Error(`ENode ${e} does not exist`);
-    i.source = t || void 0;
+    o.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
+   * @todo if calls to this method at each build operation ends causes slowness see to optimize by restricting checked elements
    */
   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 o of this.components.values())
+      t = Math.max(t, Math.abs(o.position.x), Math.abs(o.position.y));
+    for (const o of this.enodes.values()) {
+      if (o.type === m.Pin) continue;
+      const i = o.position;
+      i && (t = Math.max(t, Math.abs(i.x), Math.abs(i.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));
+    for (const o of this.wires.values())
+      for (const i of o.intermediatePositions)
+        t = Math.max(t, Math.abs(i.x), Math.abs(i.y));
     return Math.ceil(t * 2 + Math.max(e, 0));
   }
   /**
@@ -979,115 +963,27 @@ class O {
    * ```
    */
   static fromJSON(e) {
-    const t = new O();
-    t.metadata = v.fromJSON(e.metadata);
+    const t = N.fromJSON(e.metadata), o = new x(t.options);
+    o.metadata = t;
     for (const i of e.components) {
-      const n = C.fromJSON(
-        i
-      );
-      t.components.set(n.id, n);
+      const n = _.fromJSON(i);
+      o.components.set(n.id, n);
     }
     for (const i of e.enodes) {
-      const n = w.fromJSON(
-        i
-      );
-      t.enodes.set(n.id, n);
+      const n = I.fromJSON(i);
+      o.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);
+        const n = w.fromJSON(i);
+        o.wires.set(n.id, n);
+        const s = o.enodes.get(n.node1), c = o.enodes.get(n.node2);
+        s && s.wires.add(n.id), c && c.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;
+    return o;
   }
 }
-class m {
+class v {
   /**
    * Component UUID this state belongs to.
    * @readonly
@@ -1115,7 +1011,7 @@ class m {
     return this.componentId === e.componentId;
   }
 }
-class B extends m {
+class Y extends v {
   /**
    * Create a new battery state.
    *
@@ -1125,262 +1021,462 @@ class B extends m {
     super(e, "on");
   }
 }
-class k {
-  componentType = p.Battery;
+class q extends v {
   /**
-   * Create initial state for a battery.
+   * Create a new Lightbulb state.
    *
-   * @param component - The Battery component
-   * @returns Battery Initial state (always active and delivering voltage)
+   * @param componentId - UUID of the Lightbulb component
+   * @param initialState - Initial operational state (default: "off")
    */
-  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;
+  constructor(e, t = "off") {
+    super(e, t);
   }
   /**
-   * 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
+   * Check if Lightbulb is in lit state (on or going_on)
    */
-  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: []
-    };
+  get isLit() {
+    return this.state === "on" || this.state === "goingOn";
   }
 }
-class W extends m {
+class V extends v {
   /**
-   * Create a new Lightbulb state.
+   * Create a new SmallLED state.
    *
-   * @param componentId - UUID of the Lightbulb component
+   * @param componentId - UUID of the LED 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)
+   * Check if LED is in lit state (on or going_on)
    */
   get isLit() {
     return this.state === "on" || this.state === "goingOn";
   }
 }
-class x {
-  componentType = p.Lightbulb;
+class Q extends V {
+}
+class Z extends v {
   /**
-   * Create initial state for a lightbulb.
+   * Create a new Relay state.
    *
-   * @param component - The lightbulb component
-   * @returns lightbulbInitial state (always active and delivering voltage)
+   * @param componentId - UUID of the Relay component
+   * @param initialState - Initial operational state (default: "open")
    */
-  createInitialState(e) {
-    if (e.type !== p.Lightbulb)
-      throw new Error(`Invalid component type for lightbulbBehavior: ${e.type}`);
-    return new W(e.id);
+  constructor(e, t = "open") {
+    super(e, t);
   }
-  allowConductivity(e, t, i, n, s) {
-    return !0;
+  /**
+   * Check if relay is in opening or closing state
+   */
+  get isInTransition() {
+    return this.state === "closing" || this.state === "opening";
   }
   /**
-   * @param component
-   * @param state
-   * @param nodeStates
-   * @param targetTick
+   * Check if relay is in closed or closing state
    */
-  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
-    };
+  get isClosed() {
+    return this.state === "closed" || this.state === "closing";
   }
-  onUserCommand(e, t, i) {
-    return {
-      componentState: t,
-      hasChanged: !1,
-      scheduledEvents: []
-    };
+}
+class j extends v {
+  /**
+   * 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);
   }
-  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: []
-    };
+  /**
+   * 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 N extends m {
+class ee extends v {
   /**
-   * Create a new SmallLED state.
+   * Create a new double Switch state.
    *
-   * @param componentId - UUID of the LED component
-   * @param initialState - Initial operational state (default: "off")
+   * @param componentId - UUID of the double Switch component
+   * @param initialState - Initial operational state (default: "input1")
    */
-  constructor(e, t = "off") {
+  constructor(e, t = "input1") {
     super(e, t);
   }
   /**
-   * Check if LED is in lit state (on or going_on)
+   * Check if switch is in 1to2 or 2to1 state
    */
-  get isLit() {
-    return this.state === "on" || this.state === "goingOn";
+  get isInTransition() {
+    return this.state === "1to2" || this.state === "2to1";
   }
 }
-class I {
-  componentType = p.SmallLED;
+class g extends v {
   /**
-   * Create initial state for a smallLED.
+   * Create a new Inverter state.
    *
-   * @param component - The smallLED component
-   * @returns LED Initial state (always active and delivering voltage)
+   * @param componentId - UUID of the Inverter component
+   * @param initialState - Initial operational state (default: "low")
    */
-  createInitialState(e) {
-    if (e.type !== p.SmallLED)
-      throw new Error(`Invalid component type for SmallLEDBehavior: ${e.type}`);
-    return new N(e.id);
+  constructor(e, t = "low") {
+    super(e, t);
   }
-  allowConductivity(e, t, i, n, s) {
-    return !0;
+  /**
+   * Check if output is in a rising or falling transition
+   */
+  get isInTransition() {
+    return this.state === "rising" || this.state === "falling";
   }
   /**
-   * only symmetrical behavior of LEDS is handled for now
-   * @param component
-   * @param state
-   * @param nodeStates
-   * @param targetTick
+   * Check if output is high
+   */
+  get isHigh() {
+    return this.state === "high";
+  }
+}
+class te extends g {
+  /**
+   * Create a new Inverter state.
+   *
+   * @param componentId - UUID of the Inverter component
+   * @param initialState - Initial operational state (default: "low")
+   */
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class ne extends g {
+  /**
+   * Create a new NAND Gate state.
+   *
+   * @param componentId - UUID of the NAND Gate component
+   * @param initialState - Initial operational state (default: "low")
    */
-  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({
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class ie extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class oe extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class se extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class re extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class ae extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class ce extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class ue extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class he extends g {
+  constructor(e, t = "low") {
+    super(e, t);
+  }
+}
+class Oe {
+  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 y {
+  /**
+   * Component type this behavior handles (e.g., "battery", "led", "switch").
+   * Used as the key in BehaviorRegistry.
+   */
+  _componentType;
+  constructor(e) {
+    this._componentType = e;
+  }
+  get componentType() {
+    return this._componentType;
+  }
+  get typeMetadata() {
+    const e = G[this._componentType];
+    if (!e)
+      throw new Error(`Unknown metadata for Component type ${this._componentType}`);
+    return e;
+  }
+  getPinStates(e, t) {
+    const o = /* @__PURE__ */ new Map();
+    for (const i of e.pins)
+      o.set(e.getPinLabel(i), t.get(i));
+    return o;
+  }
+  /**
+   * Default: nothing happens
+   * @param _component
+   * @param componentState
+   * @param _nodeStates
+   * @param _targetTick
+   */
+  onPinsChange(e, t, o, i) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  /**
+   * Default: no conductivity between pins
+   * @param _component
+   * @param _state
+   * @param _conductivityType
+   * @param _pinId
+   * @param _otherPinId
+   */
+  allowConductivity(e, t, o, i, n) {
+    return !1;
+  }
+  onUserCommand(e, t, o) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+  onEventFiring(e, t, o) {
+    return {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    };
+  }
+}
+class de extends y {
+  constructor() {
+    super(h.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 !== this._componentType)
+      throw new Error(`Invalid component type for BatteryBehavior: ${e.type}`);
+    return new Y(e.id);
+  }
+}
+class L extends y {
+  getBehavior(e, t, o, i) {
+    let n = !1;
+    const s = [];
+    return o ? (t.state === "off" || t.state === "goingOff") && (n = !0, t.state = "goingOn", t.startTick = i, s.push({
       targetId: e.id,
-      scheduledAtTick: n,
-      readyAtTick: n + 1,
-      // TODO handle component config later
+      scheduledAtTick: i,
+      readyAtTick: i + 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({
+    }), t.state = "goingOn") : (t.state === "on" || t.state === "goingOn") && (n = !0, t.state = "goingOff", t.startTick = i, s.push({
       targetId: e.id,
-      scheduledAtTick: n,
-      readyAtTick: n + 1,
-      // TODO handle component config later
+      scheduledAtTick: i,
+      readyAtTick: i + 1,
+      // TODO handle component config later ?
       type: "GoingOffEnd",
       parameters: void 0
-    })), {
+    }), t.state = "goingOff"), {
       componentState: t,
-      hasChanged: a,
-      scheduledEvents: r
+      hasChanged: n,
+      shouldCancelPending: !1,
+      scheduledEvents: s
     };
   }
-  onUserCommand(e, t, i) {
-    return {
-      componentState: t,
-      hasChanged: !1,
-      scheduledEvents: []
-    };
+  allowConductivity(e, t, o, i, n) {
+    return !0;
   }
-  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"), {
+  onEventFiring(e, t, o) {
+    let i = !1;
+    return o.type === "GoingOffEnd" ? t.state !== "off" && (i = !0, t.startTick = o.readyAtTick, t.state = "off") : o.type === "GoingOnEnd" && t.state !== "on" && (i = !0, t.startTick = o.readyAtTick, t.state = "on"), {
       componentState: t,
-      hasChanged: n,
+      hasChanged: i,
+      shouldCancelPending: !1,
       scheduledEvents: []
     };
   }
 }
-class $ extends N {
+function $(a) {
+  if (!a)
+    return S.TRANSITION_SPAN_TICKS;
+  const e = parseInt(a.get("tickCount") || "", 10);
+  return isNaN(e) || e < 1 ? S.TRANSITION_SPAN_TICKS : e;
 }
-class M extends I {
-  componentType = p.RectangleLED;
+class le extends L {
+  constructor() {
+    super(h.Lightbulb);
+  }
   /**
-   * Create initial state for a RectangleLED.
+   * Create initial state for a lightbulb.
    *
-   * @param component - The smallLED component
-   * @returns LED Initial state (always active and delivering voltage)
+   * @param component - The lightbulb component
+   * @returns lightbulbInitial 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);
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for lightbulbBehavior: ${e.type}`);
+    return new q(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")
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
    */
-  constructor(e, t = "open") {
-    super(e, t);
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o);
+    let s = n.get("pin1").hasVoltage && n.get("pin1").hasCurrent || n.get("pin2").hasVoltage && n.get("pin2").hasCurrent || n.get("pin1").hasVoltage && n.get("pin2").hasCurrent || n.get("pin2").hasVoltage && n.get("pin1").hasCurrent;
+    return this.getBehavior(e, t, s, i);
+  }
+}
+class ge extends L {
+  constructor() {
+    super(h.RectangleLED);
   }
   /**
-   * Check if relay is in opening or closing state
+   * Create initial state for a RectangleLED.
+   *
+   * @param component - The smallLED component
+   * @returns LED Initial state (always active and delivering voltage)
    */
-  get isInTransition() {
-    return this.state === "closing" || this.state === "opening";
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for RectangleLEDBehavior: ${e.type}`);
+    return new Q(e.id);
   }
   /**
-   * Check if relay is in closed or closing state
+   * only symmetrical behavior of LEDS is handled for now
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
    */
-  get isClosed() {
-    return this.state === "closed" || this.state === "closing";
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o);
+    let s = n.get("pin2").hasVoltage && n.get("pin2").hasCurrent || n.get("pin1").hasVoltage && n.get("pin1").hasCurrent || n.get("pin2").hasVoltage && n.get("pin1").hasCurrent || n.get("pin1").hasVoltage && n.get("pin2").hasCurrent;
+    return this.getBehavior(e, t, s, i);
   }
 }
-function D(d) {
-  const e = parseInt(d.get("transitionSpan") || "", 10);
-  return isNaN(e) || e < 1 ? y.TRANSITION_SPAN_TICKS : e;
+function pe(a) {
+  const e = parseInt(a.get("transitionSpan") || "", 10);
+  return isNaN(e) || e < 1 ? S.TRANSITION_SPAN_TICKS : e;
 }
-class R {
-  componentType = p.Relay;
+class fe extends y {
+  constructor() {
+    super(h.Relay);
+  }
   /**
    * Create initial state for a relay.
    *
@@ -1388,16 +1484,16 @@ class R {
    * @returns Relay Initial state (open by default)
    */
   createInitialState(e) {
-    if (e.type !== p.Relay)
+    if (e.type !== this._componentType)
       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);
+    return new Z(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];
+  allowConductivity(e, t, o, i, n) {
+    if (i === n) return !0;
+    const s = e.getPinLabel(i), c = e.getPinLabel(n);
+    if (!s || !c) return !1;
+    const r = [s, c];
     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;
   }
   /**
@@ -1407,101 +1503,71 @@ class R {
    * @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;
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = n.get("cmd_in").hasVoltage && n.get("cmd_in").hasCurrent || n.get("cmd_out").hasVoltage && n.get("cmd_out").hasCurrent || n.get("cmd_in").hasVoltage && n.get("cmd_out").hasCurrent || n.get("cmd_out").hasVoltage && n.get("cmd_in").hasCurrent, c = e.config.get("activationLogic") === "negative" ? !s : s;
     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({
+    const u = [], d = pe(e.config);
+    return c ? (t.state === "open" || t.state === "opening") && (r = !0, t.state = "closing", t.startTick = i, u.push({
       targetId: e.id,
-      scheduledAtTick: n,
-      readyAtTick: n + l,
+      scheduledAtTick: i,
+      readyAtTick: i + d,
       type: "ClosingEnd",
       parameters: void 0
-    })) : (t.state === "closed" || t.state === "closing") && (r = !0, t.state = "opening", t.startTick = n, c.push({
+    })) : (t.state === "closed" || t.state === "closing") && (r = !0, t.state = "opening", t.startTick = i, u.push({
       targetId: e.id,
-      scheduledAtTick: n,
-      readyAtTick: n + l,
+      scheduledAtTick: i,
+      readyAtTick: i + d,
       type: "OpeningEnd",
       parameters: void 0
     })), {
       componentState: t,
       hasChanged: r,
-      scheduledEvents: c
-    };
-  }
-  onUserCommand(e, t, i) {
-    return {
-      componentState: t,
-      hasChanged: !1,
-      scheduledEvents: []
+      shouldCancelPending: !1,
+      scheduledEvents: u
     };
   }
-  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"), {
+  onEventFiring(e, t, o) {
+    let i = !1;
+    return o.type === "ClosingEnd" ? t.state !== "closed" && (i = !0, t.startTick = o.readyAtTick, t.state = "closed") : o.type === "OpeningEnd" && t.state !== "open" && (i = !0, t.startTick = o.readyAtTick, t.state = "open"), {
       componentState: t,
-      hasChanged: n,
+      hasChanged: i,
+      shouldCancelPending: !1,
       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 ve extends L {
+  constructor() {
+    super(h.SmallLED);
   }
-}
-class V extends m {
   /**
-   * Create a new Transistor state.
+   * Create initial state for a smallLED.
    *
-   * @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
+   * @param component - The smallLED component
+   * @returns LED Initial state (always active and delivering voltage)
    */
-  get isInTransition() {
-    return this.state === "closing" || this.state === "opening";
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for SmallLEDBehavior: ${e.type}`);
+    return new V(e.id);
   }
   /**
-   * Check if transistor is in closed or closing state
+   * only symmetrical behavior of LEDS is handled for now
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
    */
-  get isClosed() {
-    return this.state === "closed" || this.state === "closing";
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o);
+    let s = n.get("pin2").hasVoltage && n.get("pin2").hasCurrent || n.get("pin1").hasVoltage && n.get("pin1").hasCurrent || n.get("pin2").hasVoltage && n.get("pin1").hasCurrent || n.get("pin1").hasVoltage && n.get("pin2").hasCurrent;
+    return this.getBehavior(e, t, s, i);
   }
 }
-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;
+class we extends y {
+  constructor() {
+    super(h.Switch);
+  }
   /**
    * Create initial state for a switch.
    *
@@ -1509,175 +1575,543 @@ class z {
    * @returns Switch Initial state (open by default)
    */
   createInitialState(e) {
-    if (e.type !== p.Switch)
+    if (e.type !== this._componentType)
       throw new Error(`Invalid component type for SwitchBehavior: ${e.type}`);
     const t = e.config.get("initialState") || "open";
-    return new F(e.id, t);
+    return new j(e.id, t);
   }
-  allowConductivity(e, t, i, n, s) {
+  allowConductivity(e, t, o, i, n) {
     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) {
+  onUserCommand(e, t, o) {
+    let i = !1;
+    const n = [];
+    if (o.type === "toggle_switch" && ["open", "closed"].includes(t.state)) {
+      t.state = t.state === "open" ? "closing" : "opening", t.startTick = o.scheduledAtTick + 1, i = !0;
+      const s = $(o.parameters);
+      n.push({
+        targetId: e.id,
+        scheduledAtTick: t.startTick,
+        readyAtTick: t.startTick + s,
+        type: t.state === "closing" ? "ClosingEnd" : "OpeningEnd",
+        parameters: void 0
+      });
+    }
     return {
       componentState: t,
-      hasChanged: !1,
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: n
+    };
+  }
+  onEventFiring(e, t, o) {
+    let i = !1;
+    return o.type === "ClosingEnd" ? t.state !== "closed" && (i = !0, t.startTick = o.readyAtTick, t.state = "closed") : o.type === "OpeningEnd" && t.state !== "open" && (i = !0, t.startTick = o.readyAtTick, t.state = "open"), {
+      componentState: t,
+      hasChanged: i,
+      shouldCancelPending: !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({
+}
+class ye extends y {
+  constructor() {
+    super(h.DoubleThrowSwitch);
+  }
+  /**
+   * Create initial state for a double throw switch (SPDT).
+   *
+   * @param component - The double Switch component
+   * @returns double Switch Initial state (input1 by default)
+   */
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for DoubleThrowSwitchBehavior: ${e.type}`);
+    const t = e.config.get("initialState") || "input1";
+    return new ee(e.id, t);
+  }
+  allowConductivity(e, t, o, i, n) {
+    if (i === n) return !0;
+    const s = e.getPinLabel(i), c = e.getPinLabel(n);
+    if (!s || !c) return !1;
+    const r = [s, c];
+    return r.includes("output") && r.includes("input1") ? t.state === "input1" || t.state === "1to2" : r.includes("output") && r.includes("input2") ? t.state === "input2" || t.state === "2to1" : !1;
+  }
+  onUserCommand(e, t, o) {
+    let i = !1;
+    const n = [];
+    if (o.type === "toggle_switch" && ["input1", "input2"].includes(t.state)) {
+      t.state = t.state === "input1" ? "1to2" : "2to1", t.startTick = o.scheduledAtTick + 1, i = !0;
+      const s = $(o.parameters);
+      n.push({
         targetId: e.id,
         scheduledAtTick: t.startTick,
-        readyAtTick: t.startTick + o,
-        type: t.state === "closing" ? "ClosingEnd" : "OpeningEnd",
+        readyAtTick: t.startTick + s,
+        type: t.state === "1to2" ? "ContactedInput2" : "ContactedInput1",
         parameters: void 0
       });
     }
     return {
       componentState: t,
-      hasChanged: n,
-      scheduledEvents: s
+      hasChanged: i,
+      shouldCancelPending: !1,
+      scheduledEvents: n
     };
   }
-  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"), {
+  onEventFiring(e, t, o) {
+    let i = !1;
+    return o.type === "ContactedInput2" ? t.state !== "input2" && (i = !0, t.startTick = o.readyAtTick, t.state = "input2") : o.type === "ContactedInput1" && t.state !== "input1" && (i = !0, t.startTick = o.readyAtTick, t.state = "input1"), {
       componentState: t,
-      hasChanged: n,
+      hasChanged: i,
+      shouldCancelPending: !1,
       scheduledEvents: []
     };
   }
 }
-function G(d) {
-  const e = parseInt(d.get("transitionSpan") || "", 10);
-  return isNaN(e) || e < 1 ? y.TRANSITION_SPAN_TICKS : e;
+function me(a) {
+  const e = parseInt(a.get("transitionSpan") || "", 10);
+  return isNaN(e) || e < 1 ? S.TRANSITION_SPAN_TICKS : e;
 }
-class K {
-  componentType = p.Transistor;
+class p extends y {
   /**
-   * 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;
+   * default return for all logic gates when vcc fails -> go low immediately
+   * @param state
+   * @param pinStates
+   * @protected
+   */
+  vccGuardBehavior(e, t, o) {
+    if (t.get("vcc").hasVoltage)
+      return null;
+    e.startTick = e.state === "low" ? e.startTick : o;
+    const n = e.state !== "low", s = e.state !== "low";
+    return e.state = "low", {
+      componentState: e,
+      hasChanged: n,
+      shouldCancelPending: s,
+      scheduledEvents: []
+    };
   }
   /**
-   * Transistor Base need to have only voltage so that transistor contactor stays closed
-   * @param component
+   * guard scanning all inputs of logic gates to detect if Any has:
+   * - both voltage and ground hence with established flowing current
+   * - neither voltage nor ground
+   * it makes a not well-defined input between LOW and HIGH
+   * in that case gate goes to state indeterminate and output nothing too
    * @param state
-   * @param nodeStates
+   * @param pinStates
    * @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
+   * @protected
+   */
+  nonLogicInputGuardBehavior(e, t, o) {
+    let i = !1;
+    const n = this.typeMetadata.pins;
+    for (const [r, u] of t) {
+      if (!n.has(r)) continue;
+      const d = n.get(r);
+      if (d && d?.subtype === "logicInput") {
+        if (u.hasVoltage && u.hasCurrent) {
+          i = !0;
+          break;
+        }
+        if (!u.hasVoltage && !u.hasCurrent) {
+          i = !0;
+          break;
+        }
+      }
+    }
+    if (!i)
+      return null;
+    e.startTick = e.state === "indeterminate" ? e.startTick : o;
+    const s = e.state !== "indeterminate", c = e.state !== "indeterminate";
+    return e.state = "indeterminate", {
+      componentState: e,
+      hasChanged: s,
+      shouldCancelPending: c,
+      scheduledEvents: []
     };
   }
-  onUserCommand(e, t, i) {
-    return {
+  getBehavior(e, t, o, i) {
+    const n = me(e.config);
+    return ["low", "rising", "high", "falling", "indeterminate"].includes(t.state) || (t.state = "low"), o ? t.state === "low" || t.state === "indeterminate" ? (t.state = "rising", t.startTick = i, {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: i,
+        readyAtTick: i + n,
+        type: "RisingComplete",
+        parameters: void 0
+      }]
+    }) : t.state === "rising" || t.state === "high" ? {
       componentState: t,
       hasChanged: !1,
+      shouldCancelPending: !1,
       scheduledEvents: []
-    };
+    } : (t.state = "high", {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      // goes back to high immediately and cancel pending FallingComplete event
+      scheduledEvents: []
+    }) : t.state === "falling" || t.state === "low" ? {
+      componentState: t,
+      hasChanged: !1,
+      shouldCancelPending: !1,
+      scheduledEvents: []
+    } : t.state === "high" ? (t.state = "falling", t.startTick = i, {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !1,
+      scheduledEvents: [{
+        targetId: e.id,
+        scheduledAtTick: i,
+        readyAtTick: i + n,
+        type: "FallingComplete",
+        parameters: void 0
+      }]
+    }) : (t.state = "low", {
+      componentState: t,
+      hasChanged: !0,
+      shouldCancelPending: !0,
+      // goes back to low immediately and cancel pending RisingComplete event
+      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"), {
+  allowConductivity(e, t, o, i, n) {
+    if (i === n) return !0;
+    const s = e.getPinLabel(i), c = e.getPinLabel(n);
+    if (!s || !c) return !1;
+    const r = [s, c];
+    return r.includes("vcc") && r.includes("output") ? t.state === "high" || t.state === "falling" : r.includes("gnd") && r.includes("output") ? t.state === "low" || t.state === "rising" : !1;
+  }
+  onEventFiring(e, t, o) {
+    let i = !1;
+    return o.type === "RisingComplete" ? t.state !== "high" && (i = !0, t.startTick = o.readyAtTick, t.state = "high") : o.type === "FallingComplete" && t.state !== "low" && (i = !0, t.startTick = o.readyAtTick, t.state = "low"), {
       componentState: t,
-      hasChanged: n,
+      hasChanged: i,
+      shouldCancelPending: !1,
       scheduledEvents: []
     };
   }
 }
-function Y(d) {
-  return d.register(new k()).register(new x()).register(new M()).register(new R()).register(new I()).register(new z()).register(new K()), d;
+class Se extends p {
+  constructor() {
+    super(h.Inverter);
+  }
+  /**
+   * Create initial state for a Inverter.
+   *
+   * @param component - The Inverter component
+   * @returns Inverter Initial state (HIGH if input LOW, LOW if input LOW for positive activation logic)
+   */
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for InverterBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new te(e.id, t);
+  }
+  /**
+   * Inverter needs LOW on input to drive the output HIGH, and on the contrary Buffer needs HIGH on input to output HIGH
+   * @param component
+   * @param state
+   * @param nodeStates
+   * @param targetTick
+   */
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Ce extends p {
+  constructor() {
+    super(h.NandGate);
+  }
+  /**
+   * Create initial state for an NAND Gate.
+   *
+   * @param component - The NAND Gate component
+   * @returns Initial state (low by default, high for negative activation logic)
+   */
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for NandGateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new ne(e.id, t);
+  }
+  /**
+   * NAND gate output goes high when ANY inputs LACK voltage.
+   * With positive activationLogic (AND), output goes high when ALL inputs HAS voltage.
+   */
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage && n.get("input2").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Ne extends p {
+  constructor() {
+    super(h.Nand4Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Nand4GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new ie(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage && n.get("input2").hasVoltage && n.get("input3").hasVoltage && n.get("input4").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Be extends p {
+  constructor() {
+    super(h.Nand8Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Nand8GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new oe(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage && n.get("input2").hasVoltage && n.get("input3").hasVoltage && n.get("input4").hasVoltage && n.get("input5").hasVoltage && n.get("input6").hasVoltage && n.get("input7").hasVoltage && n.get("input8").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Ie extends p {
+  constructor() {
+    super(h.NorGate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for NorGateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new se(e.id, t);
+  }
+  /**
+   * NOR gate output goes high when ALL inputs LACK voltage.
+   * With positive activationLogic (OR), output goes high when ANY inputs HAS voltage.
+   */
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage || n.get("input2").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Pe extends p {
+  constructor() {
+    super(h.Nor4Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Nor4GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new re(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage || n.get("input2").hasVoltage || n.get("input3").hasVoltage || n.get("input4").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Te extends p {
+  constructor() {
+    super(h.Nor8Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Nor8GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new ae(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage || n.get("input2").hasVoltage || n.get("input3").hasVoltage || n.get("input4").hasVoltage || n.get("input5").hasVoltage || n.get("input6").hasVoltage || n.get("input7").hasVoltage || n.get("input8").hasVoltage, u = e.config.get("activationLogic") === "negative" ? !r : r;
+    return this.getBehavior(e, t, u, i);
+  }
+}
+class Ee extends p {
+  constructor() {
+    super(h.XorGate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for XorGateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new ce(e.id, t);
+  }
+  /**
+   * XOR gate output goes high when inputs differ (odd parity).
+   * With negative activationLogic (XNOR), output goes high when inputs are equal (even parity).
+   */
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const r = n.get("input1").hasVoltage, u = n.get("input2").hasVoltage, d = r !== u, l = e.config.get("activationLogic") === "negative" ? !d : d;
+    return this.getBehavior(e, t, l, i);
+  }
+}
+class Ge extends p {
+  constructor() {
+    super(h.Xor4Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Xor4GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new ue(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const u = ((n.get("input1").hasVoltage ? 1 : 0) + (n.get("input2").hasVoltage ? 1 : 0) + (n.get("input3").hasVoltage ? 1 : 0) + (n.get("input4").hasVoltage ? 1 : 0)) % 2 === 1, d = e.config.get("activationLogic") === "negative" ? !u : u;
+    return this.getBehavior(e, t, d, i);
+  }
+}
+class Le extends p {
+  constructor() {
+    super(h.Xor8Gate);
+  }
+  createInitialState(e) {
+    if (e.type !== this._componentType)
+      throw new Error(`Invalid component type for Xor8GateBehavior: ${e.type}`);
+    const t = e.config.get("activationLogic") === "negative" ? "high" : "low";
+    return new he(e.id, t);
+  }
+  onPinsChange(e, t, o, i) {
+    const n = this.getPinStates(e, o), s = this.vccGuardBehavior(t, n, i);
+    if (s)
+      return s;
+    const c = this.nonLogicInputGuardBehavior(t, n, i);
+    if (c)
+      return c;
+    const u = ((n.get("input1").hasVoltage ? 1 : 0) + (n.get("input2").hasVoltage ? 1 : 0) + (n.get("input3").hasVoltage ? 1 : 0) + (n.get("input4").hasVoltage ? 1 : 0) + (n.get("input5").hasVoltage ? 1 : 0) + (n.get("input6").hasVoltage ? 1 : 0) + (n.get("input7").hasVoltage ? 1 : 0) + (n.get("input8").hasVoltage ? 1 : 0)) % 2 === 1, d = e.config.get("activationLogic") === "negative" ? !u : u;
+    return this.getBehavior(e, t, d, i);
+  }
+}
+function Ae(a) {
+  return a.register(new de()).register(new le()).register(new ge()).register(new fe()).register(new ve()).register(new we()).register(new ye()), a;
+}
+function xe(a) {
+  return a.register(new Se()).register(new Ce()).register(new Ne()).register(new Be()).register(new Ie()).register(new Pe()).register(new Te()).register(new Ee()).register(new Ge()).register(new Le()), a;
 }
 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
+  Me as ALL_LOGIC_FAMILIES,
+  de as BatteryBehavior,
+  Y as BatteryState,
+  Oe as BehaviorRegistry,
+  E as CIRCUIT_FILE_VERSION,
+  G as COMPONENT_TYPE_METADATA,
+  A as CameraOptions,
+  x as Circuit,
+  N as CircuitMetadata,
+  C as CircuitOptions,
+  Re as CircuitRunner,
+  _ as Component,
+  v as ComponentState,
+  h as ComponentType,
+  O as DEFAULT_LOGIC_FAMILY,
+  De as DirtyTracker,
+  ye as DoubleThrowSwitchBehavior,
+  ee as DoubleThrowSwitchState,
+  I as ENode,
+  We as ENodeSourceType,
+  m as ENodeType,
+  ke as EventQueue,
+  Se as InverterBehavior,
+  te as InverterState,
+  le as LightbulbBehavior,
+  q as LightbulbState,
+  W as Memoize,
+  be as MemoizeExpiring,
+  Ne as Nand4GateBehavior,
+  ie as Nand4GateState,
+  Be as Nand8GateBehavior,
+  oe as Nand8GateState,
+  Ce as NandGateBehavior,
+  ne as NandGateState,
+  Pe as Nor4GateBehavior,
+  re as Nor4GateState,
+  Te as Nor8GateBehavior,
+  ae as Nor8GateState,
+  Ie as NorGateBehavior,
+  se as NorGateState,
+  R as Position,
+  Fe as Position3D,
+  ge as RectangleLEDBehavior,
+  Q as RectangleLEDState,
+  fe as RelayBehavior,
+  Z as RelayState,
+  Xe as Rotation,
+  Je as SIMULATION_SPEED,
+  Ue as SimulationState,
+  ve as SmallLEDBehavior,
+  V as SmallLEDState,
+  ze as StateManager,
+  we as SwitchBehavior,
+  j as SwitchState,
+  S as TRANSITION_DEFAULTS,
+  w as Wire,
+  Ge as Xor4GateBehavior,
+  ue as Xor4GateState,
+  Le as Xor8GateBehavior,
+  he as Xor8GateState,
+  Ee as XorGateBehavior,
+  ce as XorGateState,
+  H as classifyGate,
+  K as computeGateDelay,
+  U as computeTransitionSpan,
+  D as findPositionBestIndex,
+  M as generateUUID,
+  Ae as registerBasicComponentsBehaviors,
+  xe as registerGatesComponentsBehaviors,
+  P as simplifyPositions
 };
 //# sourceMappingURL=index.js.map