@celox-sim/celox 0.1.6 → 0.1.7

package/src/matchers.ts

@@ -70,7 +70,7 @@ function isFourStateRef(v: unknown): v is FourStateRef {
 // Matcher implementations
 // ---------------------------------------------------------------------------
 
-function getMask(received: unknown): number | bigint {
+function getMask(received: unknown): bigint {
   if (!isFourStateRef(received)) {
     throw new TypeError(
       "toBeX/toBeAllX/toBeNotX matchers require a FourStateRef. " +
@@ -84,7 +84,7 @@ function getMask(received: unknown): number | bigint {
 const customMatchers = {
   toBeX(received: unknown) {
     const mask = getMask(received);
-    const pass = mask !== 0 && mask !== 0n;
+    const pass = mask !== 0n;
     return {
       pass,
       message: () =>
@@ -100,10 +100,7 @@ const customMatchers = {
     }
     const [, mask] = readFourState(received.buffer, received.layout);
     const width = received.layout.width;
-    const allOnes =
-      width <= 53
-        ? (width === 53 ? Number.MAX_SAFE_INTEGER : (1 << width) - 1)
-        : (1n << BigInt(width)) - 1n;
+    const allOnes = (1n << BigInt(width)) - 1n;
     const pass = mask === allOnes;
     return {
       pass,
@@ -116,7 +113,7 @@ const customMatchers = {
 
   toBeNotX(received: unknown) {
     const mask = getMask(received);
-    const pass = mask === 0 || mask === 0n;
+    const pass = mask === 0n;
     return {
       pass,
       message: () =>

package/src/simulation.test.ts

@@ -12,9 +12,9 @@ import { SimulationTimeoutError } from "./types.js";
 // ---------------------------------------------------------------------------
 
 interface TopPorts {
-  rst: number;
-  d: number;
-  readonly q: number;
+  rst: bigint;
+  d: bigint;
+  readonly q: bigint;
 }
 
 const TopModule: ModuleDefinition<TopPorts> = {
@@ -127,11 +127,11 @@ describe("Simulation", () => {
       __nativeCreate: mock.create,
     });
 
-    sim.dut.d = 42;
+    sim.dut.d = 42n;
     sim.runUntil(100);
 
     expect(mock.handle.runUntil).toHaveBeenCalledWith(100);
-    expect(sim.dut.q).toBe(42);
+    expect(sim.dut.q).toBe(42n);
   });
 
   test("step", () => {
@@ -140,11 +140,11 @@ describe("Simulation", () => {
       __nativeCreate: mock.create,
     });
 
-    sim.dut.d = 0xAB;
+    sim.dut.d = 0xABn;
     const t = sim.step();
 
     expect(t).toBe(5);
-    expect(sim.dut.q).toBe(0xAB);
+    expect(sim.dut.q).toBe(0xABn);
   });
 
   test("time", () => {
@@ -240,7 +240,7 @@ describe("Simulation", () => {
       __nativeCreate: mock.create,
     });
 
-    sim.dut.d = 42;
+    sim.dut.d = 42n;
     let callCount = 0;
     const t = sim.waitUntil(() => {
       callCount++;

package/src/simulation.ts

@@ -381,8 +381,8 @@ export class Simulation<P = Record<string, unknown>> {
       );
     }
     const isActiveLow = typeKind === "reset_async_low" || typeKind === "reset_sync_low";
-    const activeValue = isActiveLow ? 0 : 1;
-    const inactiveValue = isActiveLow ? 1 : 0;
+    const activeValue = isActiveLow ? 0n : 1n;
+    const inactiveValue = isActiveLow ? 1n : 0n;
 
     const dut = this._dut as Record<string, unknown>;
     dut[signal] = activeValue;

package/src/simulator.test.ts

@@ -11,10 +11,10 @@ import type {
 // ---------------------------------------------------------------------------
 
 interface AdderPorts {
-  rst: number;
-  a: number;
-  b: number;
-  readonly sum: number;
+  rst: bigint;
+  a: bigint;
+  b: bigint;
+  readonly sum: bigint;
 }
 
 const AdderModule: ModuleDefinition<AdderPorts> = {
@@ -80,11 +80,11 @@ describe("Simulator", () => {
       __nativeCreate: mock.create,
     });
 
-    sim.dut.a = 100;
-    sim.dut.b = 200;
+    sim.dut.a = 100n;
+    sim.dut.b = 200n;
     sim.tick();
 
-    expect(sim.dut.sum).toBe(300);
+    expect(sim.dut.sum).toBe(300n);
     expect(mock.handle.tick).toHaveBeenCalledTimes(1);
   });
 
@@ -176,7 +176,7 @@ describe("Simulator", () => {
       __nativeCreate: mock.create,
     });
 
-    sim.dut.a = 100;
+    sim.dut.a = 100n;
     sim.tick();
 
     // After tick, reading output should NOT trigger evalComb

package/src/simulator.ts

@@ -234,12 +234,16 @@ export class Simulator<P = Record<string, unknown>> {
       ticks = 1;
     }
 
+    if (this._state.dirty) {
+      this._handle.evalComb();
+      this._state.dirty = false;
+    }
+
     if (ticks === 1) {
       this._handle.tick(eventId);
     } else if (ticks > 1) {
       this._handle.tickN(eventId, ticks);
     }
-    this._state.dirty = false;
   }
 
   /** Resolve an event name to a handle for use with `tick()`. */

package/src/types.ts

@@ -160,8 +160,8 @@ export const X = Symbol.for("veryl:X");
 /** A 4-state value with explicit bit-level mask. */
 export interface FourStateValue {
   readonly __fourState: true;
-  readonly value: number | bigint;
-  readonly mask: number | bigint;
+  readonly value: bigint;
+  readonly mask: bigint;
 }
 
 /** Construct a 4-state value. Mask bits set to 1 indicate X. */
@@ -169,7 +169,7 @@ export function FourState(
   value: number | bigint,
   mask: number | bigint,
 ): FourStateValue {
-  return { __fourState: true, value, mask };
+  return { __fourState: true, value: BigInt(value), mask: BigInt(mask) };
 }
 
 export function isFourStateValue(v: unknown): v is FourStateValue {