@celox-sim/celox 0.1.6 → 0.1.7

package/src/dut.test.ts

@@ -41,11 +41,11 @@ describe("createDut — scalar ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
-    dut.a = 42;
+    dut.a = 42n;
     expect(state.dirty).toBe(true);
-    expect(dut.a).toBe(42);
+    expect(dut.a).toBe(42n);
     // Reading an input doesn't trigger evalComb
     expect(handle.evalComb).not.toHaveBeenCalled();
   });
@@ -61,10 +61,10 @@ describe("createDut — scalar ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
-    dut.a = 0xABCD;
-    expect(dut.a).toBe(0xABCD);
+    dut.a = 0xABCDn;
+    expect(dut.a).toBe(0xABCDn);
   });
 
   test("write and read 32-bit input", () => {
@@ -78,13 +78,13 @@ describe("createDut — scalar ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
-    dut.a = 0xDEAD_BEEF;
-    expect(dut.a).toBe(0xDEAD_BEEF);
+    dut.a = 0xDEAD_BEEFn;
+    expect(dut.a).toBe(0xDEAD_BEEFn);
   });
 
-  test("write and read 48-bit value (fits in number)", () => {
+  test("write and read 48-bit value", () => {
     const buffer = makeBuffer(64);
     const layout: Record<string, SignalLayout> = {
       a: { offset: 0, width: 48, byteSize: 8, is4state: false, direction: "input" },
@@ -95,9 +95,9 @@ describe("createDut — scalar ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
-    const val = 0x1234_5678_9ABC;
+    const val = 0x1234_5678_9ABCn;
     dut.a = val;
     expect(dut.a).toBe(val);
   });
@@ -131,10 +131,10 @@ describe("createDut — scalar ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
-    dut.a = 0xFF; // Only lower 4 bits should be stored
-    expect(dut.a).toBe(0x0F);
+    dut.a = 0xFFn; // Only lower 4 bits should be stored
+    expect(dut.a).toBe(0x0Fn);
   });
 });
 
@@ -156,12 +156,12 @@ describe("createDut — dirty tracking", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number; readonly sum: number }>(
+    const dut = createDut<{ a: bigint; readonly sum: bigint }>(
       buffer, layout, ports, handle, state,
     );
 
     // Write input → dirty
-    dut.a = 100;
+    dut.a = 100n;
     expect(state.dirty).toBe(true);
 
     // Read output → evalComb should be called
@@ -181,7 +181,7 @@ describe("createDut — dirty tracking", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ readonly sum: number }>(
+    const dut = createDut<{ readonly sum: bigint }>(
       buffer, layout, ports, handle, state,
     );
 
@@ -200,7 +200,7 @@ describe("createDut — dirty tracking", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: true };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     void dut.a;
     expect(handle.evalComb).not.toHaveBeenCalled();
@@ -217,10 +217,10 @@ describe("createDut — dirty tracking", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ sum: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ sum: bigint }>(buffer, layout, ports, handle, state);
 
     expect(() => {
-      dut.sum = 42;
+      dut.sum = 42n;
     }).toThrow("Cannot write to output port 'sum'");
   });
 });
@@ -243,7 +243,7 @@ describe("createDut — clock ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     expect(Object.keys(dut as object)).toEqual(["a"]);
     expect((dut as any).clk).toBeUndefined();
@@ -281,20 +281,20 @@ describe("createDut — multiple signals", () => {
 
     const state: DirtyState = { dirty: false };
     const dut = createDut<{
-      rst: number;
-      a: number;
-      b: number;
-      readonly sum: number;
+      rst: bigint;
+      a: bigint;
+      b: bigint;
+      readonly sum: bigint;
     }>(buffer, layout, ports, handle, state);
 
-    dut.a = 100;
-    dut.b = 200;
+    dut.a = 100n;
+    dut.b = 200n;
     // sum read triggers evalComb
-    expect(dut.sum).toBe(300);
+    expect(dut.sum).toBe(300n);
     expect(handle.evalComb).toHaveBeenCalledTimes(1);
 
     // second read without changes → no evalComb
-    expect(dut.sum).toBe(300);
+    expect(dut.sum).toBe(300n);
     expect(handle.evalComb).toHaveBeenCalledTimes(1);
   });
 });
@@ -316,13 +316,13 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     (dut as any).a = X;
     // Value should be 0, mask should be 0xFF
     const [value, mask] = readFourState(buffer, layout.a);
-    expect(value).toBe(0);
-    expect(mask).toBe(0xFF);
+    expect(value).toBe(0n);
+    expect(mask).toBe(0xFFn);
   });
 
   test("write FourState to a 4-state signal", () => {
@@ -336,12 +336,12 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     (dut as any).a = FourState(0b1010, 0b0100);
     const [value, mask] = readFourState(buffer, layout.a);
-    expect(value).toBe(0b1010);
-    expect(mask).toBe(0b0100);
+    expect(value).toBe(0b1010n);
+    expect(mask).toBe(0b0100n);
   });
 
   test("writing X to non-4-state signal throws", () => {
@@ -355,7 +355,7 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     expect(() => {
       (dut as any).a = X;
@@ -373,7 +373,7 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     expect(() => {
       (dut as any).a = FourState(0xA5, 0x0F);
@@ -391,18 +391,18 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     // First write X
     (dut as any).a = X;
     const [, maskBefore] = readFourState(buffer, layout.a);
-    expect(maskBefore).toBe(0xFF);
+    expect(maskBefore).toBe(0xFFn);
 
     // Then write a defined value — mask should clear
-    dut.a = 42;
+    dut.a = 42n;
     const [value, maskAfter] = readFourState(buffer, layout.a);
-    expect(value).toBe(42);
-    expect(maskAfter).toBe(0);
+    expect(value).toBe(42n);
+    expect(maskAfter).toBe(0n);
   });
 
   test("reading 4-state output returns value part only", () => {
@@ -417,14 +417,14 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ readonly y: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ readonly y: bigint }>(buffer, layout, ports, handle, state);
 
     // Set value=0xAB, mask=0x0F (lower 4 bits are X)
     view.setUint8(0, 0xAB);
     view.setUint8(1, 0x0F);
 
     // DUT getter returns the value part
-    expect(dut.y).toBe(0xAB);
+    expect(dut.y).toBe(0xABn);
   });
 
   test("write X sets dirty flag", () => {
@@ -438,7 +438,7 @@ describe("createDut — 4-state", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ a: number }>(buffer, layout, ports, handle, state);
+    const dut = createDut<{ a: bigint }>(buffer, layout, ports, handle, state);
 
     (dut as any).a = X;
     expect(state.dirty).toBe(true);
@@ -462,20 +462,20 @@ describe("createDut — array ports", () => {
     const handle = mockHandle();
     const state: DirtyState = { dirty: false };
 
-    const dut = createDut<{ data: number[] }>(
+    const dut = createDut<{ data: { at(i: number): bigint; set(i: number, v: bigint): void; length: number } }>(
       buffer, layout, ports, handle, state,
     );
 
-    (dut.data as any)[0] = 0xAA;
-    (dut.data as any)[1] = 0xBB;
-    (dut.data as any)[2] = 0xCC;
-    (dut.data as any)[3] = 0xDD;
+    dut.data.set(0, 0xAAn);
+    dut.data.set(1, 0xBBn);
+    dut.data.set(2, 0xCCn);
+    dut.data.set(3, 0xDDn);
 
-    expect((dut.data as any)[0]).toBe(0xAA);
-    expect((dut.data as any)[1]).toBe(0xBB);
-    expect((dut.data as any)[2]).toBe(0xCC);
-    expect((dut.data as any)[3]).toBe(0xDD);
-    expect((dut.data as any).length).toBe(4);
+    expect(dut.data.at(0)).toBe(0xAAn);
+    expect(dut.data.at(1)).toBe(0xBBn);
+    expect(dut.data.at(2)).toBe(0xCCn);
+    expect(dut.data.at(3)).toBe(0xDDn);
+    expect(dut.data.length).toBe(4);
   });
 });
 
@@ -515,20 +515,20 @@ describe("createDut — interface ports", () => {
     const state: DirtyState = { dirty: false };
     const dut = createDut<{
       bus: {
-        addr: number;
-        data: number;
-        valid: number;
-        readonly ready: number;
+        addr: bigint;
+        data: bigint;
+        valid: bigint;
+        readonly ready: bigint;
       };
     }>(buffer, layout, ports, handle, state);
 
-    dut.bus.addr = 0x1000;
-    dut.bus.data = 0xFF;
-    dut.bus.valid = 1;
+    dut.bus.addr = 0x1000n;
+    dut.bus.data = 0xFFn;
+    dut.bus.valid = 1n;
 
-    expect(dut.bus.addr).toBe(0x1000);
-    expect(dut.bus.data).toBe(0xFF);
-    expect(dut.bus.ready).toBe(1);
+    expect(dut.bus.addr).toBe(0x1000n);
+    expect(dut.bus.data).toBe(0xFFn);
+    expect(dut.bus.ready).toBe(1n);
     expect(handle.evalComb).toHaveBeenCalledTimes(1);
   });
 });

package/src/dut.ts

@@ -116,27 +116,27 @@ function writeBigInt(
   }
 }
 
-/** Read a signal value from the DataView. Returns number or bigint. */
+/** Read a signal value from the DataView. Always returns bigint. */
 function readSignal(
   view: DataView,
   sig: SignalLayout,
-): number | bigint {
+): bigint {
   if (sig.width <= 53) {
-    return readNumber(view, sig.offset, sig.width);
+    return BigInt(readNumber(view, sig.offset, sig.width));
   }
   return readBigInt(view, sig.offset, sig.byteSize);
 }
 
-/** Write a signal value to the DataView. Accepts number or bigint. */
+/** Write a signal value to the DataView. Accepts bigint (number accepted for compat). */
 function writeSignal(
   view: DataView,
   sig: SignalLayout,
-  value: number | bigint,
+  value: bigint | number,
 ): void {
-  if (sig.width <= 53 && typeof value === "number") {
-    writeNumber(view, sig.offset, sig.width, value);
+  const bigVal = typeof value === "bigint" ? value : BigInt(value);
+  if (sig.width <= 53) {
+    writeNumber(view, sig.offset, sig.width, Number(bigVal));
   } else {
-    const bigVal = typeof value === "bigint" ? value : BigInt(value);
     writeBigInt(view, sig.offset, sig.byteSize, bigVal);
   }
 }
@@ -162,11 +162,8 @@ function writeFourState(
 /** Write all-X mask for a signal. */
 function writeAllX(view: DataView, sig: SignalLayout): void {
   // Value = 0, mask = all 1s
-  writeSignal(view, sig, sig.width <= 53 ? 0 : 0n);
-  const allOnes =
-    sig.width <= 53
-      ? (sig.width === 53 ? Number.MAX_SAFE_INTEGER : (1 << sig.width) - 1)
-      : (1n << BigInt(sig.width)) - 1n;
+  writeSignal(view, sig, 0n);
+  const allOnes = (1n << BigInt(sig.width)) - 1n;
   const maskLayout: SignalLayout = {
     offset: sig.offset + sig.byteSize,
     width: sig.width,
@@ -348,7 +345,7 @@ function defineSignalProperty(
   const isInput = port?.direction === "input";
 
   Object.defineProperty(target, name, {
-    get(): number | bigint {
+    get(): bigint {
       // Output reads: lazy evalComb if dirty
       if (state.dirty && !isInput) {
         handle.evalComb();
@@ -357,7 +354,7 @@ function defineSignalProperty(
       return readSignal(view, sig);
     },
 
-    set(value: number | bigint | symbol | FourStateValue) {
+    set(value: bigint | number | symbol | FourStateValue) {
       if (isOutput) {
         throw new Error(`Cannot write to output port '${name}'`);
       }
@@ -373,7 +370,8 @@ function defineSignalProperty(
         }
         writeFourState(view, sig, value);
       } else {
-        writeSignal(view, sig, value as number | bigint);
+        const bigVal = typeof value === "bigint" ? value : BigInt(value as number);
+        writeSignal(view, sig, bigVal);
         // Clear mask when writing a defined value to a 4-state signal
         if (sig.is4state) {
           const maskLayout: SignalLayout = {
@@ -383,7 +381,7 @@ function defineSignalProperty(
             is4state: false,
             direction: sig.direction,
           };
-          writeSignal(view, maskLayout, sig.width <= 53 ? 0 : 0n);
+          writeSignal(view, maskLayout, 0n);
         }
       }
 
@@ -460,19 +458,19 @@ function createArrayDut(
   return {
     length: totalElements,
 
-    at(i: number): number | bigint {
+    at(i: number): bigint {
       if (state.dirty && !isInput) {
         handle.evalComb();
         state.dirty = false;
       }
       const offset = baseOffset + i * elementByteSize;
       if (elementWidth <= 53) {
-        return readNumber(view, offset, elementWidth);
+        return BigInt(readNumber(view, offset, elementWidth));
       }
       return readBigInt(view, offset, elementByteSize);
     },
 
-    set(i: number, value: number | bigint | symbol | FourStateValue): void {
+    set(i: number, value: bigint | number | symbol | FourStateValue): void {
       if (isOutput) {
         throw new Error("Cannot write to output array port");
       }
@@ -495,13 +493,20 @@ function createArrayDut(
           is4state, direction: baseSig.direction,
         };
         writeFourState(view, elemSig, value);
-      } else if (elementWidth <= 53 && typeof value === "number") {
-        writeNumber(view, offset, elementWidth, value);
-        if (is4state) writeNumber(view, offset + elementByteSize, elementWidth, 0);
       } else {
         const bigVal = typeof value === "bigint" ? value : BigInt(value as number);
-        writeBigInt(view, offset, elementByteSize, bigVal);
-        if (is4state) writeBigInt(view, offset + elementByteSize, elementByteSize, 0n);
+        const elemSig: SignalLayout = {
+          offset, width: elementWidth, byteSize: elementByteSize,
+          is4state, direction: baseSig.direction,
+        };
+        writeSignal(view, elemSig, bigVal);
+        if (is4state) {
+          const maskSig: SignalLayout = {
+            offset: offset + elementByteSize, width: elementWidth,
+            byteSize: elementByteSize, is4state: false, direction: baseSig.direction,
+          };
+          writeSignal(view, maskSig, 0n);
+        }
       }
       state.dirty = true;
     },
@@ -519,7 +524,7 @@ function createArrayDut(
 export function readFourState(
   buffer: ArrayBuffer | SharedArrayBuffer,
   sig: SignalLayout,
-): [value: number | bigint, mask: number | bigint] {
+): [value: bigint, mask: bigint] {
   if (!sig.is4state) {
     throw new Error("Signal is not 4-state");
   }

package/src/e2e.bench.ts

@@ -39,8 +39,8 @@ const CODE = `
 `;
 
 interface TopPorts {
-  rst: number;
-  readonly cnt: { at(i: number): number; readonly length: number };
+  rst: bigint;
+  readonly cnt: { at(i: number): bigint; readonly length: number };
 }
 
 describe("simulation", () => {
@@ -56,9 +56,9 @@ describe("simulation", () => {
   const sim = Simulator.fromSource<TopPorts>(CODE, "Top");
 
   // Reset sequence
-  sim.dut.rst = 1;
+  sim.dut.rst = 1n;
   sim.tick();
-  sim.dut.rst = 0;
+  sim.dut.rst = 0n;
   sim.tick();
 
   afterAll(() => {
@@ -81,7 +81,7 @@ describe("simulation", () => {
 
   // Testbench pattern: write input + tick + read back
   bench("testbench_tick_top_n1000_x1", () => {
-    sim.dut.rst = 0;
+    sim.dut.rst = 0n;
     sim.tick();
     // biome-ignore lint: read to measure full testbench cycle
     sim.dut.rst;
@@ -91,7 +91,7 @@ describe("simulation", () => {
     "testbench_tick_top_n1000_x1000000",
     () => {
       for (let i = 0; i < 1_000_000; i++) {
-        sim.dut.rst = 0;
+        sim.dut.rst = 0n;
         sim.tick();
         // biome-ignore lint: read to measure full testbench cycle
         sim.dut.rst;
@@ -116,9 +116,9 @@ describe("simulation", () => {
   const simArr = Simulator.create<TopPorts>(TopModule, {
     __nativeCreate: createSimulatorBridge(addon),
   });
-  simArr.dut.rst = 1;
+  simArr.dut.rst = 1n;
   simArr.tick();
-  simArr.dut.rst = 0;
+  simArr.dut.rst = 0n;
   simArr.tick();
 
   afterAll(() => {
@@ -126,7 +126,7 @@ describe("simulation", () => {
   });
 
   bench("testbench_array_tick_top_n1000_x1", () => {
-    simArr.dut.rst = 0;
+    simArr.dut.rst = 0n;
     simArr.tick();
     // biome-ignore lint: read array element to measure .at() overhead
     simArr.dut.cnt.at(0);
@@ -136,7 +136,7 @@ describe("simulation", () => {
     "testbench_array_tick_top_n1000_x1000000",
     () => {
       for (let i = 0; i < 1_000_000; i++) {
-        simArr.dut.rst = 0;
+        simArr.dut.rst = 0n;
         simArr.tick();
         // biome-ignore lint: read array element to measure .at() overhead
         simArr.dut.cnt.at(0);
@@ -155,9 +155,9 @@ describe("simulation", () => {
 describe("overhead", () => {
   // Simulator.tick — same as Rust simulator_tick_x10000
   const simTick = Simulator.fromSource<TopPorts>(CODE, "Top");
-  simTick.dut.rst = 1;
+  simTick.dut.rst = 1n;
   simTick.tick();
-  simTick.dut.rst = 0;
+  simTick.dut.rst = 0n;
   simTick.tick();
 
   afterAll(() => {
@@ -270,18 +270,18 @@ describe("testbench-helpers", () => {
   `;
 
   interface CounterPorts {
-    rst: number;
-    en: number;
-    readonly count: number;
+    rst: bigint;
+    en: bigint;
+    readonly count: bigint;
   }
 
   // waitForCycles benchmark
   const simWait = Simulation.fromSource<CounterPorts>(COUNTER_CODE, "Counter");
   simWait.addClock("clk", { period: 10 });
-  simWait.dut.rst = 1;
+  simWait.dut.rst = 1n;
   simWait.runUntil(20);
-  simWait.dut.rst = 0;
-  simWait.dut.en = 1;
+  simWait.dut.rst = 0n;
+  simWait.dut.en = 1n;
 
   afterAll(() => {
     simWait.dispose();
@@ -308,10 +308,10 @@ describe("testbench-helpers", () => {
   // runUntil: fast Rust path vs guarded TS path
   const simRun = Simulation.fromSource<CounterPorts>(COUNTER_CODE, "Counter");
   simRun.addClock("clk", { period: 10 });
-  simRun.dut.rst = 1;
+  simRun.dut.rst = 1n;
   simRun.runUntil(20);
-  simRun.dut.rst = 0;
-  simRun.dut.en = 1;
+  simRun.dut.rst = 0n;
+  simRun.dut.en = 1n;
 
   afterAll(() => {
     simRun.dispose();
@@ -363,17 +363,17 @@ describe("optimize-flag", () => {
   );
 
   const simNoOpt = Simulator.fromSource<TopPorts>(CODE, "Top");
-  simNoOpt.dut.rst = 1;
+  simNoOpt.dut.rst = 1n;
   simNoOpt.tick();
-  simNoOpt.dut.rst = 0;
+  simNoOpt.dut.rst = 0n;
   simNoOpt.tick();
 
   const simOpt = Simulator.fromSource<TopPorts>(CODE, "Top", {
     optimize: true,
   });
-  simOpt.dut.rst = 1;
+  simOpt.dut.rst = 1n;
   simOpt.tick();
-  simOpt.dut.rst = 0;
+  simOpt.dut.rst = 0n;
   simOpt.tick();
 
   afterAll(() => {