feat: sequential chips

Author: r2abreu

.gitignore

@@ -0,0 +1 @@
+.vscode

bit/bit.test.ts

@@ -1,52 +1,62 @@
 import { assertEquals } from "jsr:@std/assert";
-import Bit from "./bit.ts";
-import clock from "../clock/clock.ts"; // Adjust as needed
+import Bit from "./bit.ts"; // Adjust the import as needed
 
 Deno.test("Bit: outputs 0 initially", () => {
-  const bit = Bit();
-  assertEquals(bit(0, 0), 0);
-  assertEquals(bit(1, 0), 0);
+  const bit = Bit(0, 0);
+  assertEquals(bit.value, 0);
 });
 
 Deno.test("Bit: loads and stores a 1", () => {
-  const bit = Bit();
-  assertEquals(bit(1, 1), 0); // Set input=1, load=1, output still 0
-  clock.tick();
-  clock.tock();
-  assertEquals(bit(0, 0), 1); // Output updates to 1
+  const bit = Bit(0, 0);
+  assertEquals(bit.value, 0);
+
+  bit.in = 1;
+  bit.load = 1;
+  bit.tick();
+  bit.tock();
+
+  assertEquals(bit.value, 1);
 });
 
 Deno.test("Bit: holds value when load is 0", () => {
-  const bit = Bit();
-  bit(1, 1); // Prepare to store 1
-  clock.tick();
-  clock.tock();
-  assertEquals(bit(0, 0), 1); // Output is 1
-
-  bit(0, 0); // load=0, input=0, should not change
-  clock.tick();
-  clock.tock();
-  assertEquals(bit(0, 0), 1); // Output still 1
+  const bit = Bit(0, 0);
+
+  bit.in = 1;
+  bit.load = 1;
+  bit.tick();
+  bit.tock();
+  assertEquals(bit.value, 1);
+
+  bit.in = 0;
+  bit.load = 0;
+  bit.tick();
+  bit.tock();
+  assertEquals(bit.value, 1); // Should still hold the previous value
 });
 
 Deno.test("Bit: can reset to 0 when load is 1", () => {
-  const bit = Bit();
-  bit(1, 1);
-  clock.tick();
-  clock.tock();
-  assertEquals(bit(0, 0), 1);
-
-  bit(0, 1); // load=1, input=0, should store 0
-  clock.tick();
-  clock.tock();
-  assertEquals(bit(0, 0), 0);
+  const bit = Bit(0, 0);
+
+  bit.in = 1;
+  bit.load = 1;
+  bit.tick();
+  bit.tock();
+  assertEquals(bit.value, 1);
+
+  bit.in = 0;
+  bit.load = 1;
+  bit.tick();
+  bit.tock();
+  assertEquals(bit.value, 0);
 });
 
 Deno.test("Bit: does not change output until tock", () => {
-  const bit = Bit();
-  bit(1, 1);
-  clock.tick();
-  assertEquals(bit(0, 0), 0); // Output not updated yet
-  clock.tock();
-  assertEquals(bit(0, 0), 1); // Output updated after tock
+  const bit = Bit(0, 0);
+
+  bit.in = 1;
+  bit.load = 1;
+  bit.tick();
+  assertEquals(bit.value, 0); // Output not updated yet
+  bit.tock();
+  assertEquals(bit.value, 1); // Output updated after tock
 });

bit/bit.ts

@@ -1,30 +1,56 @@
 import dff from "../dff/dff.ts";
 import type { bit } from "../utility.ts";
 
-export default function (): (_in: bit, load: bit) => bit {
-  const _dff = dff();
-
-  /**
-   * @module Bit
-   *
-   * @param {bit} in - 1-bit input value
-   * @param {bit} load - 1-bit load signal (1: store input, 0: keep current)
-   * @returns {object} out - Bit interface with getter for output and setters for input/load
-   *
-   * Input:  in (bit), load (bit)
-   * Output: out (bit)
-   * Function:
-   *   If load == 1, stores `in` on next clock cycle.
-   *   If load == 0, preserves previous value.
-   *
-   * The Bit chip is a 1-bit register built from a DFF.
-   */
+/**
+ * @module Bit
+ *
+ * @param {bit} in - 1-bit input value
+ * @param {bit} load - 1-bit load signal (1: store input, 0: keep current)
+ * @returns {object} out - Bit interface with getter for output and setters for input/load
+ *
+ * Input:  in (bit), load (bit)
+ * Output: out (bit)
+ * Function:
+ *   If load == 1, stores `in` on next clock cycle.
+ *   If load == 0, preserves previous value.
+ *
+ * The Bit chip is a 1-bit register built from a DFF.
+ */
+interface Bit {
+  value: bit;
+  in: bit;
+  load: bit;
+  tick: () => void;
+  tock: () => void;
+}
 
-  return function (_in: bit, load: bit): bit {
-    if (load) {
-      _dff.value = _in;
-    }
+export default function (_in: bit = 0, load: bit = 0): Bit {
+  const _dff = dff();
+  let __in: bit = _in;
+  let _load: bit = load;
 
-    return _dff.value;
+  return {
+    get in() {
+      return __in;
+    },
+    set in(val: bit) {
+      __in = val;
+    },
+    get load() {
+      return _load;
+    },
+    set load(val: bit) {
+      _load = val;
+    },
+    get value() {
+      return _dff.value;
+    },
+    tick() {
+      if (_load) _dff.value = __in;
+      _dff.tick();
+    },
+    tock() {
+      _dff.tock();
+    },
   };
 }

clock/clock.ts

@@ -1,6 +1,6 @@
 {
   "name": "@r2/hack",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "MIT",
   "exports": {
     ".": "./main.ts"

deno.json

@@ -1,6 +1,5 @@
 import { assertEquals } from "jsr:@std/assert";
 import DFF from "./dff.ts";
-import clock from "../clock/clock.ts";
 
 Deno.test("DFF: outputs 0 initially", () => {
   const dff = DFF();
@@ -17,21 +16,21 @@ Deno.test("DFF: latches input on tick and updates output on tock", () => {
   assertEquals(dff.value, 0);
 
   // Tick: sample input
-  clock.tick();
+  dff.tick();
 
   // Output should still be 0 before tock
   assertEquals(dff.value, 0);
 
   // Tock: output updates to previous input
-  clock.tock();
+  dff.tock();
   assertEquals(dff.value, 1);
 
   // Change input to 0, output remains 1 until next tick/tock
   dff.value = 0;
   assertEquals(dff.value, 1);
-  clock.tick();
+  dff.tick();
   assertEquals(dff.value, 1);
-  clock.tock();
+  dff.tock();
   assertEquals(dff.value, 0);
 });
 
@@ -40,19 +39,19 @@ Deno.test("DFF: handles multiple cycles", () => {
 
   // Cycle 1: input 1
   dff.value = 1;
-  clock.tick();
-  clock.tock();
+  dff.tick();
+  dff.tock();
   assertEquals(dff.value, 1);
 
   // Cycle 2: input 0
   dff.value = 0;
-  clock.tick();
-  clock.tock();
+  dff.tick();
+  dff.tock();
   assertEquals(dff.value, 0);
 
   // Cycle 3: input 1
   dff.value = 1;
-  clock.tick();
-  clock.tock();
+  dff.tick();
+  dff.tock();
   assertEquals(dff.value, 1);
 });

dff/dff.test.ts

@@ -1,4 +1,3 @@
-import clock from "../clock/clock.ts";
 import type { bit } from "../utility.ts";
 
 /**
@@ -17,28 +16,32 @@ import type { bit } from "../utility.ts";
  * It updates its output in sync with the system clock's tick/tock phases.
  */
 
-export default function (): Record<string, bit> {
+interface DFF {
+  value: bit;
+  tick: () => void;
+  tock: () => void;
+}
+
+export default function (): DFF {
   let output: bit = 0;
   let next: bit = 0;
   let input: bit = 0;
 
-  const obj = {
+  return {
     get value() {
       return output;
     },
 
     set value(newVal: bit) {
       input = newVal;
     },
-  };
-
-  clock.addEventListener("tick", () => {
-    next = input;
-  });
 
-  clock.addEventListener("tock", () => {
-    output = next;
-  });
+    tick() {
+      next = input;
+    },
 
-  return obj;
+    tock() {
+      output = next;
+    },
+  };
 }

dff/dff.ts

@@ -22,5 +22,11 @@ export { default as dff } from "./dff/dff.ts";
 export { default as bit } from "./bit/bit.ts";
 export { default as register } from "./register/register.ts";
 export { default as ram8 } from "./ram8/ram8.ts"
+export { default as ram64 } from "./ram64/ram64.ts"
+export { default as ram512 } from "./ram512/ram512.ts"
+export { default as ram4k } from "./ram4k/ram4k.ts"
+export { default as ram16k } from "./ram16k/ram16k.ts"
+export { default as pc } from "./pc/pc.ts"
+
 
 export * from "./utility.ts";