simple-circuit-engine 0.0.12 → 0.0.14

package/AGENTS.md

@@ -35,15 +35,15 @@ registerGatesComponentsFactories(componentsFactoryRegistry); //... other groups
 const behaviorRegistry = registerBasicComponentsBehaviors(new BehaviorRegistry());
 registerGatesComponentsBehaviors(behaviorRegistry); //... other groupsof components  if needed
 
+// Rendering (must exist before engine.initialize — it binds MapControls to the canvas)
+const renderer = new WebGLRenderer();
+
 // Instanciate and Initialize CircuitEngine (it creates and uses a new Circuit by default)
 const engine = new CircuitEngine(componentsFactoryRegistry, behaviorRegistry);
 const container = document.getElementById('canvas-container')!;
-engine.initialize(container, engineOptions());
+engine.initialize(container, renderer, engineOptions());
 // set engine circuit to a new empty circuit
 engine.setCircuit(new Circuit(new CircuitOptions()));
-
-// Rendering
-const renderer = new WebGLRenderer();
 const width = window.innerWidth,
   height = window.innerHeight;
 renderer.setSize(container.clientWidth, container.clientHeight);
@@ -121,8 +121,10 @@ animate();
 ### Initialize Engine
 
 ```typescript
+const renderer = new WebGLRenderer();
 const engine = new CircuitEngine(factoryRegistry, behaviorRegistry);
-engine.initialize(container, engineOptions());
+engine.initialize(container, renderer, engineOptions());
+container.appendChild(renderer.domElement);
 engine.setCircuit(new Circuit());
 
 // Add Component Programmatically
@@ -160,6 +162,7 @@ engine.on('simulationTick', (state) => { ... });
 
 ```json
 {
-  "three": "^0.183.2"
+  "three": "^0.183.2",
+  "i18next": ">=25.0.0 <27.0.0"
 }
 ```

package/CLAUDE.md

@@ -18,6 +18,7 @@ However, it aims to teach real-world electronic design principles so modeling of
 - TypeScript 6.0+ (strict mode), targeting ES2022
 - Three.js 0.183+ (scene, camera, controls, 3D objects, Line2)
 - lil-gui as helper for small interactive modal forms
+- i18next for internationalization (see `src/i18n/CLAUDE.md` for conventions)
 - in-memory circuit model, optional loading/saving from/to a JSON file
 
 ## Project Structure
@@ -26,6 +27,7 @@ Simple Circuit Engine follows a **Model-Controller** architecture with clear sep
 
 - **Core module** (`src/core/`): Pure TypeScript domain **Model** and simulation engine (no dependencies).
 - **Scene module** (`src/scene/`): Three.js visualization layer with editing **Controller** and its tools and the simulation animated **Controller**.
+- **i18next Internationalization** (`src/i18n/`) : localization setup and locales
 
 ### Core Module (`src/core/`)
 

package/README.md

@@ -44,21 +44,21 @@ const componentsFactoryRegistry = registerBasicComponentsFactories(new GroupedFa
 // Create behavior registry with basic components behaviors (for simulation)
 const behaviorRegistry = registerBasicComponentsBehaviors(new BehaviorRegistry());
 
+// Create and setup WebGL renderer (must exist before engine.initialize — it binds MapControls to the canvas)
+const renderer = new WebGLRenderer({ antialias: true, alpha: false });
+renderer.setClearColor(0x1a1a2e);
+const container = document.getElementById('canva-container')!;
+renderer.setSize(container.clientWidth, container.clientHeight);
+renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+
 // Initialize CircuitEngine
 // It creates THREE.js scene, camera, controls, lights, etc
 // and the interactive controllers (edit and simulation) of simple-circuit-engine
-const container = document.getElementById('canva-container')!;
 const engine = new CircuitEngine(componentsFactoryRegistry, behaviorRegistry);
-engine.initialize(container, engineOptions());
+engine.initialize(container, renderer, engineOptions());
 // set engine circuit to a new empty circuit
 engine.setCircuit(new Circuit(new CircuitOptions()));
 
-// Create and setup WebGL renderer
-const renderer = new WebGLRenderer({ antialias: true, alpha: false });
-renderer.setClearColor(0x1a1a2e);
-const width = window.innerWidth, height = window.innerHeight;
-renderer.setSize(container.clientWidth, container.clientHeight);
-renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
 // Append renderer to DOM
 container.appendChild(renderer.domElement);
 

package/dist/core/index.js

@@ -1,77 +1,112 @@
-import { $ as t, A as e, B as s, C as o, D as i, E as r, F as n, G as S, H as h, I as v, J as B, K as G, L as c, M as l, N, O as E, P as p, Q as T, R as m, S as u, T as C, U as I, V as L, W as D, X as d, Y as y, Z as g, _, _t as A, a as R, at as M, b as O, bt as b, c as P, ct as w, d as U, dt as X, et as f, f as F, ft as k, g as x, gt as z, h as Y, ht as Q, i as V, it as W, j, k as q, l as H, lt as J, m as K, mt as Z, n as $, nt as aa, o as ta, ot as ea, p as sa, pt as oa, q as ia, r as ra, rt as na, s as Sa, st as ha, t as va, tt as Ba, u as Ga, ut as ca, v as la, vt as Na, w as Ea, x as pa, y as Ta, yt as ma, z as ua } from "../core-Bjta9Y7_.js";
+import { $ as a, $t as e, A as s, At as i, B as o, Bt as r, C as n, Ct as h, D as S, Dt as B, E as v, Et as p, F as g, Ft as u, G as c, Gt as d, H as E, Ht as I, I as L, It as l, J as m, Jt as G, K as T, Kt as C, L as N, Lt as A, M as D, Mt as O, N as y, Nt as R, O as f, Ot as F, P as M, Pt as P, Q as w, Qt as _, R as b, Rt as U, S as X, St as x, T as k, Tt as W, U as z, Ut as H, V as Y, Vt as Q, W as V, Wt as j, X as q, Xt as J, Y as K, Yt as Z, Z as $, Zt as tt, _ as at, _t as et, a as st, at as it, b as ot, bt as rt, c as nt, ct as ht, d as St, dt as Bt, en as vt, et as pt, f as gt, ft as ut, g as ct, gt as dt, h as Et, ht as It, i as Lt, it as lt, j as mt, jt as Gt, k as Tt, kt as Ct, l as Nt, lt as At, m as Dt, mt as Ot, n as yt, nt as Rt, o as ft, ot as Ft, p as Mt, pt as Pt, q as wt, qt as _t, r as bt, rt as Ut, s as Xt, st as xt, t as kt, tn as Wt, tt as zt, u as Ht, ut as Yt, v as Qt, vt as Vt, w as jt, wt as qt, x as Jt, xt as Kt, y as Zt, yt as $t, z as ta, zt as aa } from "../core-HH6iRWtB.js";
 export {
-  M as ALL_LOGIC_FAMILIES,
-  Ea as BatteryBehavior,
-  D as BatteryState,
-  r as BehaviorRegistry,
-  ea as CIRCUIT_FILE_VERSION,
-  ha as COMPONENT_TYPE_METADATA,
-  A as CameraOptions,
-  d as Circuit,
-  f as CircuitMetadata,
-  Ba as CircuitOptions,
-  ra as CircuitRunner,
-  _ as ClockBehavior,
-  c as ClockState,
-  aa as Component,
-  S as ComponentState,
-  w as ComponentType,
-  J as DEFAULT_LOGIC_FAMILY,
-  R as DirtyTracker,
-  la as DoubleThrowSwitchBehavior,
-  m as DoubleThrowSwitchState,
-  W as ENode,
-  ca as ENodeSourceType,
-  X as ENodeType,
-  ta as EventQueue,
-  x as InverterBehavior,
-  v as InverterState,
-  o as LightbulbBehavior,
-  I as LightbulbState,
-  ma as Memoize,
-  b as MemoizeExpiring,
-  K as Nand4GateBehavior,
-  p as Nand4GateState,
-  sa as Nand8GateBehavior,
-  N as Nand8GateState,
-  Y as NandGateBehavior,
-  n as NandGateState,
-  U as Nor4GateBehavior,
-  j as Nor4GateState,
-  Ga as Nor8GateBehavior,
-  e as Nor8GateState,
-  F as NorGateBehavior,
-  l as NorGateState,
+  r as ALL_LOGIC_FAMILIES,
+  Jt as AdderBehavior,
+  zt as AdderState,
+  Ut as ArithmeticState,
+  o as BatteryBehavior,
+  Kt as BatteryState,
+  E as BehaviorRegistry,
+  Q as CIRCUIT_FILE_VERSION,
+  I as COMPONENT_TYPE_METADATA,
+  _ as CameraOptions,
+  Gt as Circuit,
+  u as CircuitMetadata,
+  l as CircuitOptions,
+  st as CircuitRunner,
+  y as ClockBehavior,
+  Ot as ClockState,
+  A as Component,
+  x as ComponentState,
+  H as ComponentType,
+  j as DEFAULT_LOGIC_FAMILY,
+  Xt as DirtyTracker,
+  M as DoubleThrowSwitchBehavior,
+  It as DoubleThrowSwitchState,
+  aa as ENode,
+  d as ENodeSourceType,
+  C as ENodeType,
+  ot as EightBitAdderBehavior,
+  pt as EightBitAdderState,
+  Zt as EightBitOnesComplementBehavior,
+  a as EightBitOnesComplementState,
+  Dt as EightInputBehavior,
+  m as EightInputState,
+  Nt as EightLightBehavior,
+  z as EightLightState,
+  nt as EventQueue,
+  Et as FourInputBehavior,
+  K as FourInputState,
+  Ht as FourLightBehavior,
+  V as FourLightState,
+  X as HalfAdderBehavior,
+  Rt as HalfAdderState,
+  Qt as InputBehaviorMixin,
+  w as InputState,
+  D as InverterBehavior,
+  Pt as InverterState,
+  Mt as LightBehaviorMixin,
+  wt as LightState,
+  ta as LightbulbBehavior,
+  rt as LightbulbState,
+  vt as Memoize,
+  Wt as MemoizeExpiring,
+  s as Nand4GateBehavior,
+  Bt as Nand4GateState,
+  Tt as Nand8GateBehavior,
+  Yt as Nand8GateState,
+  mt as NandGateBehavior,
+  ut as NandGateState,
+  S as Nor4GateBehavior,
+  ht as Nor4GateState,
+  v as Nor8GateBehavior,
+  xt as Nor8GateState,
+  f as NorGateBehavior,
+  At as NorGateState,
+  at as OneInputBehavior,
+  $ as OneInputState,
+  gt as OneLightBehavior,
+  T as OneLightState,
   Z as Position,
-  Na as Position3D,
-  u as RectangleLEDBehavior,
-  L as RectangleLEDState,
-  pa as RelayBehavior,
-  s as RelayState,
-  oa as Rotation,
-  B as SIMULATION_SPEED,
-  G as SimulationState,
-  O as SmallLEDBehavior,
-  h as SmallLEDState,
-  V as StateManager,
-  Ta as SwitchBehavior,
-  ua as SwitchState,
-  y as TRANSITION_DEFAULTS,
-  na as Wire,
-  P as Xor4GateBehavior,
-  E as Xor4GateState,
-  Sa as Xor8GateBehavior,
-  i as Xor8GateState,
-  H as XorGateBehavior,
-  q as XorGateState,
-  g as classifyGate,
-  T as computeGateDelay,
-  t as computeTransitionSpan,
-  Q as findPositionBestIndex,
-  k as generateUUID,
-  C as getTransitionSpan,
-  va as registerBasicComponentsBehaviors,
-  $ as registerGatesComponentsBehaviors,
-  z as simplifyPositions,
-  ia as unionElectricalStates
+  e as Position3D,
+  b as RectangleLEDBehavior,
+  Vt as RectangleLEDState,
+  N as RelayBehavior,
+  et as RelayState,
+  G as Rotation,
+  W as SIMULATION_SPEED,
+  h as SimulationState,
+  L as SmallLEDBehavior,
+  $t as SmallLEDState,
+  ft as StateManager,
+  g as SwitchBehavior,
+  dt as SwitchState,
+  p as TRANSITION_DEFAULTS,
+  ct as TwoInputBehavior,
+  q as TwoInputState,
+  St as TwoLightBehavior,
+  c as TwoLightState,
+  U as Wire,
+  jt as Xor4GateBehavior,
+  it as Xor4GateState,
+  n as Xor8GateBehavior,
+  lt as Xor8GateState,
+  k as XorGateBehavior,
+  Ft as XorGateState,
+  O as classifyGate,
+  R as computeGateDelay,
+  P as computeTransitionSpan,
+  B as findBpsAtLogicDistance,
+  F as findBpsAtLogicDistanceWithPath,
+  Ct as findPinsReachableFromBp,
+  i as findPinsReachableFromBpWithPath,
+  J as findPositionBestIndex,
+  _t as generateUUID,
+  Y as getTransitionSpan,
+  kt as registerArithmeticComponentsBehaviors,
+  yt as registerBasicComponentsBehaviors,
+  bt as registerGatesComponentsBehaviors,
+  Lt as registerInterfaceComponentsBehaviors,
+  tt as simplifyPositions,
+  qt as unionElectricalStates
 };

package/dist/core/setup.d.ts

@@ -15,3 +15,21 @@ export declare function registerBasicComponentsBehaviors(registry: BehaviorRegis
  * @return the input behavior registry for chaining
  */
 export declare function registerGatesComponentsBehaviors(registry: BehaviorRegistry): BehaviorRegistry;
+/**
+ * Register all arithmetic component behaviors in the given registry
+ * Arithmetic components are : HalfAdder, Adder, 8bit adder, 8bit one's complement
+ * @public
+ * @param registry
+ * @return the input behavior registry for chaining
+ */
+export declare function registerArithmeticComponentsBehaviors(registry: BehaviorRegistry): BehaviorRegistry;
+/**
+ * Register all interface component behaviors in the given registry.
+ * Interface components are:
+ *  - inputs: OneInput, TwoInput, FourInput, EightInput
+ *  - lights: OneLight, TwoLight, FourLight, EightLight
+ * @public
+ * @param registry
+ * @return the input behavior registry for chaining
+ */
+export declare function registerInterfaceComponentsBehaviors(registry: BehaviorRegistry): BehaviorRegistry;

package/dist/core/simulation/behaviors/arithmetic/AdderBehavior.d.ts

@@ -0,0 +1,28 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { IComponentBehavior } from '../types';
+import { ArithmeticBehaviorMixin } from './ArithmeticBehaviorMixin';
+/**
+ * Behavior for the Full Adder component (two half adders + OR on carries).
+ *
+ * Three logic inputs (`inputA`, `inputB`, `carryIn`) and two logic outputs
+ * (`sum`, `carryOut`):
+ *
+ * - `sum = A XOR B XOR carryIn` (parity of the three inputs)
+ * - `carryOut = majority(A, B, carryIn)` (two or more inputs high)
+ *
+ * State encoding follows `${sumBit}${carryBit}` — see {@link AdderState}. All
+ * four stable states are reachable; `A = B = carryIn = 1` yields `'11'`.
+ *
+ * A single medium `transitionSpan` from config is used for every transition,
+ * since modeling the cumulative XOR/AND/OR delays per input-output pair would
+ * be more complexity than this library's teaching scope warrants.
+ *
+ * @public
+ */
+export declare class AdderBehavior extends ArithmeticBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+    protected computeTargetStableState(pinStates: Map<string, INodeElectricalState>): string;
+}

package/dist/core/simulation/behaviors/arithmetic/ArithmeticBehaviorMixin.d.ts

@@ -0,0 +1,63 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { UUID } from '../../../utils/types';
+import { ENodeSourceType } from '../../../topology/types';
+import { IBehaviorResult } from '../types';
+import { IScheduledEvent } from '../../types';
+import { ComponentBehaviorMixin } from '../ComponentBehavior';
+import { ArithmeticState } from '../../states/arithmetic/ArithmeticState';
+/**
+ * Factorises the common plumbing of arithmetic component behaviors:
+ *
+ * - `vccGuardBehavior` — on vcc loss, drop all outputs low immediately.
+ * - `nonLogicInputGuardBehavior` — on any ill-defined logic input, go to
+ *   `'indeterminate'` immediately.
+ * - `onPinsChange` is a **template method** that runs the guards then calls
+ *   `computeTargetStableState` (subclass-provided) and schedules the
+ *   transition via `scheduleTransition`.
+ * - `scheduleTransition` — encode the `to${target}` transient state, schedule
+ *   the completion event and preserve the previous stable state in
+ *   `parameters.prevState` so `allowConductivity` keeps the old outputs
+ *   energized until the transition fires.
+ * - `onEventFiring` — land on the target stable state when the scheduled
+ *   transition completes.
+ * - `allowConductivity` — generic per-output lookup driven by
+ *
+ * Subclasses must declare `outputPinLabels` in the **same order** as the
+ * state encoding used by their {@link ArithmeticState} subclass and
+ * implement `computeTargetStableState` to turn the current input pins into
+ * that encoding.
+ */
+export declare abstract class ArithmeticBehaviorMixin extends ComponentBehaviorMixin {
+    /**
+     * Compute the target stable-state encoding from the current pin states.
+     * Called only after vcc / non-logic guards have passed.
+     */
+    protected abstract computeTargetStableState(pinStates: Map<string, INodeElectricalState>): string;
+    onPinsChange(component: Component, state: ComponentState, nodeStates: ReadonlyMap<UUID, INodeElectricalState>, targetTick: number): IBehaviorResult;
+    onEventFiring(_component: Component, state: ComponentState, event: IScheduledEvent): IBehaviorResult;
+    allowConductivity(component: Component, state: ComponentState, _conductivityType: ENodeSourceType, pinId: string, otherPinId: string): boolean;
+    /**
+     * On vcc loss: all outputs go low immediately.
+     * Returns `null` when vcc is present so callers can proceed.
+     */
+    protected vccGuardBehavior(state: ArithmeticState, pinStates: Map<string, INodeElectricalState>, targetTick: number): IBehaviorResult | null;
+    /**
+     * Scan all logic inputs; if any is ill-defined (both voltage and ground,
+     * or neither), switch to `'indeterminate'` immediately. Otherwise returns
+     * `null` so the caller can proceed.
+     */
+    protected nonLogicInputGuardBehavior(state: ArithmeticState, pinStates: Map<string, INodeElectricalState>, targetTick: number): IBehaviorResult | null;
+    /**
+     * Schedule a transition toward the given stable target state. If already
+     * there (or already heading there) returns a no-change result.
+     *
+     * Preserves the currently-driving stable state in `parameters.prevState` so
+     * `allowConductivity` keeps the old outputs energized until the scheduled
+     * event fires. When the previous effective state is `'indeterminate'` the
+     * fallback is all-zeros.
+     */
+    protected scheduleTransition(component: Component, state: ArithmeticState, targetState: string, targetTick: number): IBehaviorResult;
+    protected noChange(state: ComponentState): IBehaviorResult;
+}

package/dist/core/simulation/behaviors/arithmetic/EightBitAdderBehavior.d.ts

@@ -0,0 +1,51 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { IComponentBehavior, IBehaviorResult } from '../types';
+import { IScheduledEvent } from '../../types';
+import { UUID } from '../../../utils/types';
+import { ArithmeticBehaviorMixin } from './ArithmeticBehaviorMixin';
+/**
+ * Behavior for the 8-bit ripple carry adder (8 full adders in series).
+ *
+ * Unlike the single full adder whose output settles in one transition, the
+ * 8-bit adder models **carry propagation**: when inputs change, only stage 0
+ * recomputes immediately (with its own propagation delay); the carry then
+ * ripples through stages 1–7, one `transitionSpan` per stage.
+ *
+ * ### State encoding
+ *
+ * 16 interleaved bits `C7S7 C6S6 … C1S1 C0S0` stored as a 4-digit hex
+ * string. Sum at bit `2*i`, carry at bit `2*i+1`.
+ * See {@link EightBitAdderState}.
+ *
+ * ### Ripple algorithm
+ *
+ * - **`onPinsChange`**: computes ALL 8 stages with new inputs but **old
+ *   carries** from the current effective state, producing an intermediate
+ *   state. Schedules one event for carry propagation starting at stage 1.
+ *   Uses `shouldCancelPending: true` to restart the ripple cleanly when
+ *   inputs change mid-propagation.
+ *
+ * - **`onEventFiring`**: lands on the intermediate, then checks whether the
+ *   next stage's carry-in changed. If so, recomputes that stage, builds the
+ *   next intermediate, and schedules the following stage. If not, the carry
+ *   has stopped and the state is stable. Uses `shouldCancelPending: false`.
+ *
+ * - **Initialization shortcut**: at `targetTick === 0` the full stable state
+ *   is computed directly via {@link computeTargetStableState} to avoid the
+ *   init-loop limitation where chained events are dropped.
+ *
+ * @public
+ */
+export declare class EightBitAdderBehavior extends ArithmeticBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+    onPinsChange(component: Component, state: ComponentState, nodeStates: ReadonlyMap<UUID, INodeElectricalState>, targetTick: number): IBehaviorResult;
+    onEventFiring(component: Component, state: ComponentState, event: IScheduledEvent): IBehaviorResult;
+    /**
+     * Compute the fully-settled stable state by propagating the carry chain
+     * through all 8 stages. Used at initialization and for test verification.
+     */
+    protected computeTargetStableState(pinStates: Map<string, INodeElectricalState>): string;
+}

package/dist/core/simulation/behaviors/arithmetic/EightBitOnesComplementBehavior.d.ts

@@ -0,0 +1,29 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { IComponentBehavior } from '../types';
+import { ENodeSourceType } from '../../../topology/types';
+import { ArithmeticBehaviorMixin } from './ArithmeticBehaviorMixin';
+/**
+ * Behavior for the 8-bit one's complement (8 parallel XOR gates with shared
+ * `invert` input).
+ *
+ * When `invert` is high every output is the bitwise NOT of its input; when low
+ * outputs pass through unchanged. All 8 gates fire in parallel — a single
+ * `transitionSpan` covers the whole transition (no ripple).
+ *
+ * State encoding: 9 bits as a 3-hex-char string. Bits 0–7 are outputs,
+ * bit 8 is the invert flag. See {@link EightBitOnesComplementState}.
+ *
+ * The mixin's default `onPinsChange` / `onEventFiring` / `scheduleTransition`
+ * handle everything — only `computeTargetStableState` and
+ * `allowConductivity` need implementation.
+ *
+ * @public
+ */
+export declare class EightBitOnesComplementBehavior extends ArithmeticBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+    allowConductivity(component: Component, state: ComponentState, _conductivityType: ENodeSourceType, pinId: string, otherPinId: string): boolean;
+    protected computeTargetStableState(pinStates: Map<string, INodeElectricalState>): string;
+}

package/dist/core/simulation/behaviors/arithmetic/HalfAdderBehavior.d.ts

@@ -0,0 +1,22 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { IComponentBehavior } from '../types';
+import { ArithmeticBehaviorMixin } from './ArithmeticBehaviorMixin';
+/**
+ * Behavior for the Half Adder component (XOR + AND in one block).
+ *
+ * - `sum = A XOR B`
+ * - `carry = A AND B`
+ *
+ * State encoding follows `${sumBit}${carryBit}` — see {@link HalfAdderState}.
+ * Because `sum` and `carry` can never both be high, only three stable states
+ * are reachable: `'00' | '10' | '01'`.
+ *
+ * @public
+ */
+export declare class HalfAdderBehavior extends ArithmeticBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+    protected computeTargetStableState(pinStates: Map<string, INodeElectricalState>): string;
+}

package/dist/core/simulation/behaviors/arithmetic/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Arithmetic components behaviors
+ * @module core/simulation/behaviors
+ */
+export { ArithmeticBehaviorMixin } from './ArithmeticBehaviorMixin';
+export { HalfAdderBehavior } from './HalfAdderBehavior';
+export { AdderBehavior } from './AdderBehavior';

package/dist/core/simulation/behaviors/index.d.ts

@@ -22,3 +22,17 @@ export { Nor8GateBehavior } from './gates/Nor8GateBehavior';
 export { XorGateBehavior } from './gates/XorGateBehavior';
 export { Xor4GateBehavior } from './gates/Xor4GateBehavior';
 export { Xor8GateBehavior } from './gates/Xor8GateBehavior';
+export { HalfAdderBehavior } from './arithmetic/HalfAdderBehavior';
+export { AdderBehavior } from './arithmetic/AdderBehavior';
+export { EightBitAdderBehavior } from './arithmetic/EightBitAdderBehavior';
+export { EightBitOnesComplementBehavior } from './arithmetic/EightBitOnesComplementBehavior';
+export { InputBehaviorMixin } from './interface/InputBehaviorMixin';
+export { OneInputBehavior } from './interface/OneInputBehavior';
+export { TwoInputBehavior } from './interface/TwoInputBehavior';
+export { FourInputBehavior } from './interface/FourInputBehavior';
+export { EightInputBehavior } from './interface/EightInputBehavior';
+export { LightBehaviorMixin } from './interface/LightBehaviorMixin';
+export { OneLightBehavior } from './interface/OneLightBehavior';
+export { TwoLightBehavior } from './interface/TwoLightBehavior';
+export { FourLightBehavior } from './interface/FourLightBehavior';
+export { EightLightBehavior } from './interface/EightLightBehavior';

package/dist/core/simulation/behaviors/interface/EightInputBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { IComponentBehavior } from '../types';
+import { InputBehaviorMixin } from './InputBehaviorMixin';
+/** Eight-switch user input. See {@link InputBehaviorMixin}. */
+export declare class EightInputBehavior extends InputBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+}

package/dist/core/simulation/behaviors/interface/EightLightBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { IComponentBehavior } from '../types';
+import { LightBehaviorMixin } from './LightBehaviorMixin';
+/** Eight-light input mirror. See {@link LightBehaviorMixin}. */
+export declare class EightLightBehavior extends LightBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+}

package/dist/core/simulation/behaviors/interface/FourInputBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { IComponentBehavior } from '../types';
+import { InputBehaviorMixin } from './InputBehaviorMixin';
+/** Four-switch user input. See {@link InputBehaviorMixin}. */
+export declare class FourInputBehavior extends InputBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+}

package/dist/core/simulation/behaviors/interface/FourLightBehavior.d.ts

@@ -0,0 +1,9 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { IComponentBehavior } from '../types';
+import { LightBehaviorMixin } from './LightBehaviorMixin';
+/** Four-light input mirror. See {@link LightBehaviorMixin}. */
+export declare class FourLightBehavior extends LightBehaviorMixin implements IComponentBehavior {
+    constructor();
+    createInitialState(component: Component): ComponentState;
+}

package/dist/core/simulation/behaviors/interface/InputBehaviorMixin.d.ts

@@ -0,0 +1,37 @@
+import { Component } from '../../../topology/Component';
+import { ComponentState } from '../../states/ComponentState';
+import { INodeElectricalState } from '../../states/types';
+import { UUID } from '../../../utils/types';
+import { ENodeSourceType } from '../../../topology/types';
+import { IScheduledEvent, IUserCommand } from '../../types';
+import { IBehaviorResult } from '../types';
+import { ComponentBehaviorMixin } from '../ComponentBehavior';
+/**
+ * Factorises the plumbing shared by `OneInput`, `TwoInput`, `FourInput` and
+ * `EightInput` behaviors.
+ *
+ * These components only react to user actions (`toggle_input` commands) — they
+ * have no logic inputs. The state encodes the current outputs as a hex value
+ * (e.g. `'5'` = `0101` for FourInput); while at least one switch is moving the
+ * state literal is `'moving'` and a parameter map tracks each pending switch
+ * (`${index}` → `${target}-${startTick}-${endTick}`) plus the actual driving
+ * value in `prevState`.
+ *
+ * Concurrency model:
+ * - Toggling a different switch while another is still moving simply adds a
+ *   new pending entry — both transitions resolve independently. No
+ *   `shouldCancelPending`.
+ * - Toggling the *same* switch a second time is debounced (the second command
+ *   is silently ignored).
+ * - Vcc loss collapses the state to `allLowState` and clears all pending
+ *   transitions.
+ *
+ * @public
+ */
+export declare abstract class InputBehaviorMixin extends ComponentBehaviorMixin {
+    onPinsChange(component: Component, state: ComponentState, nodeStates: ReadonlyMap<UUID, INodeElectricalState>, targetTick: number): IBehaviorResult;
+    onUserCommand(component: Component, state: ComponentState, command: IUserCommand): IBehaviorResult;
+    onEventFiring(_component: Component, state: ComponentState, event: IScheduledEvent): IBehaviorResult;
+    allowConductivity(component: Component, state: ComponentState, _conductivityType: ENodeSourceType, pinId: string, otherPinId: string): boolean;
+    protected noChange(state: ComponentState): IBehaviorResult;
+}