9Volt 0.0.1__tar.gz

9volt-0.0.1/9Volt.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: 9Volt
+Version: 0.0.1
+Summary: A tiny Oblivious Compute halting-machine specimen
+Requires-Python: >=3.10
+Requires-Dist: wcwidth>=0.2

9volt-0.0.1/9Volt.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+HaltingMachine.py
+pyproject.toml
+9Volt.egg-info/PKG-INFO
+9Volt.egg-info/SOURCES.txt
+9Volt.egg-info/dependency_links.txt
+9Volt.egg-info/entry_points.txt
+9Volt.egg-info/requires.txt
+9Volt.egg-info/top_level.txt
+Machine/Spacewalk.py
+Machine/__init__.py
+Machine/field.py
+Machine/inverter.py
+Machine/observer.py
+tests/test_display_feet.py
+tests/test_genesis_default.py
+tests/test_observer_wire.py
+tests/test_trinity.py
+tests/test_v22_timing.py
+tests/test_v23_layout.py
+tests/test_v24_cadence.py
+tests/test_v25_toggle_and_pacing.py
+tests/test_v26_pingpong.py
+tests/test_v27_three_seconds.py

9volt-0.0.1/9Volt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

9volt-0.0.1/9Volt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+HaltingMachine = HaltingMachine:main

9volt-0.0.1/9Volt.egg-info/requires.txt

@@ -0,0 +1 @@
+wcwidth>=0.2

9volt-0.0.1/9Volt.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+HaltingMachine
+Machine

9volt-0.0.1/HaltingMachine.py

@@ -0,0 +1,7 @@
+import os, sys
+from Machine.field import main
+if __name__ == "__main__":
+    if sys.argv[1:] not in ([], ["Spacewalk.py"], ["Spacewalk"]):
+        raise SystemExit("Usage: python HaltingMachine.py [Spacewalk.py]")
+    os.environ["HALTING_SPACEWALK"] = "1" if sys.argv[1:] else "0"
+    main()

9volt-0.0.1/Machine/Spacewalk.py

@@ -0,0 +1,50 @@
+# Change only this value to adjust Spacewalk's proposal and doorway pace.
+INTERVAL = 3.0
+
+POSITIVE = ('000', '100', '110', '111')
+NEGATIVE = ('000', '001', '011', '111')
+LATERAL = frozenset(('010', '101'))
+
+
+class Spacewalk:
+    def __init__(self, inverted=False):
+        self.inverted = inverted
+        self.state = self.previous = '000'
+        self.doorway_at = None
+
+    @property
+    def lane(self):
+        return NEGATIVE if self.inverted else POSITIVE
+
+    @property
+    def shell(self):
+        return self.state.count('1')
+
+    def propose(self):
+        position = self.lane.index(self.state)
+        return self.lane[position + 1] if position < 3 else None
+
+    def accept(self, incoming, now=0):
+        successor = self.propose()
+        # ================= LINCHPIN ================= #
+        if incoming != successor or successor is None:
+            return None
+        # ============================================ #
+        assert sum(a != b for a, b in zip(self.state, successor)) == 1
+        self.previous, self.state = self.state, successor
+        if successor == '111': self.doorway_at = now + INTERVAL
+        return successor
+
+    def doorway(self):
+        assert self.state == '111'
+        self.previous = self.state
+        self.inverted = not self.inverted
+        self.state, self.doorway_at = '000', None
+        return self.state
+
+    def display(self):
+        emblems = ('🪨', '✂️', '📜', '🪨') if self.inverted else ('🪨', '📜', '✂️', '🪨')
+        icons = ''.join(glyph + (' ' if glyph == '✂️' else '') for glyph in emblems)
+        pointer = ' ' * (4 + 2 * self.shell)
+        left, right = (self.state, self.previous) if self.state == '000' and self.previous == '111' else (self.previous, self.state)
+        return pointer + '🔻', f'{left} {icons} {right}', pointer + '🔺'

9volt-0.0.1/Machine/__init__.py

@@ -0,0 +1 @@
+"""HaltingMachine: observer, inverter, and field."""

9volt-0.0.1/Machine/field.py

@@ -0,0 +1,75 @@
+import os, platform, random, shlex, shutil, signal, subprocess, sys, termios, tty
+from wcwidth import wcswidth
+
+
+def paint():
+    sys.stdout.write("\033[40m\033[97m\033[2J\033[H\033[?25l")
+
+
+def clear():
+    sys.stdout.write("\033[?25h\033[0m\033[2J\033[H"); sys.stdout.flush()
+
+
+def center(text):
+    return " " * max(0, (os.get_terminal_size().columns - wcswidth(text)) // 2) + text
+
+
+def choose(label, lo, hi, value):
+    old = termios.tcgetattr(sys.stdin); tty.setcbreak(sys.stdin.fileno())
+    try:
+        while True:
+            paint(); print("\n\n" + center("HaltingMachine"), "\n", center(label), "", center(str(value)), sep="\n", flush=True)
+            key = os.read(sys.stdin.fileno(), 3)
+            if key in (b"\r", b"\n"): return value
+            if key == b"\x1b[A": value = min(hi, value + 1)
+            elif key == b"\x1b[B": value = max(lo, value - 1)
+    finally: termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old)
+
+
+def terminal_command(cmd):
+    names = ("kitty", "konsole", "gnome-terminal", "xfce4-terminal", "alacritty")
+    terminal = next((shutil.which(x) for x in names if shutil.which(x)), None)
+    terminal = terminal or shutil.which(os.environ.get("TERMINAL", ""))
+    terminal = terminal or shutil.which("x-terminal-emulator") or shutil.which("xterm")
+    if not terminal: raise SystemExit("No terminal emulator found")
+    name = os.path.basename(os.path.realpath(terminal))
+    if name == "gnome-terminal": return [terminal, "--", *cmd]
+    if name == "xfce4-terminal": return [terminal, "--command", shlex.join(cmd)]
+    if name == "alacritty": return [terminal, "-T", "HaltingMachine", "-e", *cmd]
+    if name == "kitty": return [terminal, "--title", "HaltingMachine", *cmd]
+    return [terminal, "-e", *cmd]
+
+
+def spawn(module, index, total):
+    cmd = [sys.executable, "-m", module, str(index), str(total)]
+    env = os.environ.copy(); env["PYTHONIOENCODING"] = "utf-8"
+    if platform.system() == "Darwin":
+        line = shlex.join(cmd).replace('"', '\\"')
+        subprocess.Popen(["osascript", "-e", f'tell application "Terminal" to do script "{line}"'])
+    else: subprocess.Popen(terminal_command(cmd), env=env)
+
+
+def main():
+    old_handlers = {s: signal.getsignal(s) for s in (signal.SIGTSTP, signal.SIGQUIT)}
+    for s in old_handlers: signal.signal(s, signal.SIG_IGN)
+    try:
+        total = choose("OBSERVERS", 1, 10, 3)
+        inverted = choose("INVERTERS", 0, total, min(1, total))
+        first = total - inverted
+        index = random.randrange(total)
+        for i in range(total):
+            if i != index:
+                spawn("Machine.inverter" if i >= first else "Machine.observer", i, total)
+        if index >= first:
+            from .inverter import run
+        else:
+            from .observer import run
+        run(index, total)
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        for s, h in old_handlers.items(): signal.signal(s, h)
+        clear()
+
+
+if __name__ == "__main__": main()

9volt-0.0.1/Machine/inverter.py

@@ -0,0 +1,14 @@
+import sys
+from .observer import REVERSE, run as observe
+
+
+def run(index, total):
+    observe(index, total, step=REVERSE, invert_controls=True, invert_mode=True)
+
+
+def main():
+    index, total = map(int, sys.argv[1:3])
+    run(index, total)
+
+
+if __name__ == "__main__": main()

9volt-0.0.1/Machine/observer.py

@@ -0,0 +1,134 @@
+import os, select, signal, socket, sys, termios, time, tty
+from wcwidth import wcswidth
+
+ROCK, PAPER, SCISSORS = "🪨", "📜", "✂️"
+FORWARD = {ROCK: PAPER, PAPER: SCISSORS, SCISSORS: ROCK}
+REVERSE = {v: k for k, v in FORWARD.items()}
+ART = {ROCK: ROCK * 4, PAPER: PAPER * 4, SCISSORS: "✂️ " * 4}
+GREEK = ("Γ", "Δ", "Ε", "Θ", "Λ", "Π", "Σ", "Φ", "Ψ", "Ω")
+BASE = 43120
+
+def paint():
+    sys.stdout.write("\033[40m\033[97m\033[2J\033[H\033[?25l")
+
+def clear():
+    sys.stdout.write("\033[?25h\033[0m\033[2J\033[H"); sys.stdout.flush()
+
+def center(text, width=None):
+    width = wcswidth(text) if width is None else width
+    return " " * max(0, (os.get_terminal_size().columns - width) // 2) + text
+
+def draw(identity, mode, state, inverted=False, genesis=None, cube=None):
+    paint(); print("\n\n\n\n" + center(f"{identity} HaltingMachine {identity}"), "\n")
+    if genesis is not None:
+        print(center("GENESIS"), "\n", center(genesis), flush=True); return
+    face = "🙃" if inverted else "🙂"
+    halt = f"{face}HALT{face}" if mode == 0 else "HALT"
+    repeat = f"{face}REPEAT{face}" if mode else "REPEAT"
+    visuals = cube.display() if cube else (ART[state],)
+    positions = [center(text, 16 if cube else 8) for text in visuals]
+    if cube:
+        print(center(halt), center(repeat), *positions, ' ' + center("SPACE TO EXIT"), sep="\n", flush=True)
+    else:
+        print(center(halt), center(repeat), '', *positions, '', ' ' + center("SPACE TO EXIT"), sep="\n", flush=True)
+
+def send(sock, total, payload, skip):
+    data = payload.encode("utf-8")
+    for i in range(total):
+        if i != skip:
+            try: sock.sendto(data, ("127.0.0.1", BASE + i))
+            except OSError: pass
+
+def run(index, total, step=FORWARD, invert_controls=False, invert_mode=False):
+    cube = None
+    if os.environ.get("HALTING_SPACEWALK") == "1":
+        from .Spacewalk import Spacewalk, INTERVAL
+        cube = Spacewalk(invert_mode)
+    interval = INTERVAL if cube else 1.0
+    identity = GREEK[index]
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setblocking(False); sock.bind(("127.0.0.1", BASE + index))
+    seen, state, mode = {index}, ROCK, 0
+    def show(genesis=None):
+        draw(identity, mode, state, cube.inverted if cube else invert_controls, genesis, cube)
+    old = termios.tcgetattr(sys.stdin); tty.setcbreak(sys.stdin.fileno())
+    ignored = (signal.SIGTSTP, signal.SIGQUIT)
+    handlers = {s: signal.getsignal(s) for s in ignored}
+    for s in ignored: signal.signal(s, signal.SIG_IGN)
+    hello_at = ready_at = 0.0; emit_at = None if cube else 0.0; shown_seen = -1
+    try:
+        while True:
+            now = time.monotonic()
+            if cube and cube.doorway_at is not None and now >= cube.doorway_at:
+                cube.doorway()
+                mode = int(cube.inverted)
+                emit_at = None  # Doorway resets to an effectively HALTed relay.
+                show()
+            if now >= hello_at:
+                send(sock, total, f"H{index}", index); hello_at = now + .25
+            while True:
+                try: msg = sock.recvfrom(64)[0].decode("utf-8")
+                except BlockingIOError: break
+                if msg.startswith("H"):
+                    seen.add(int(msg[1:]))
+                elif cube or now >= ready_at:
+                    if cube:
+                        admitted = cube.accept(msg, now)
+                        active = (1 - mode) if cube.inverted else mode
+                        if admitted is not None and active:
+                            emit_at = now + interval  # Admission rephases the repeater.
+                        elif (admitted is None and active and emit_at is None
+                              and len(msg) == 3 and set(msg) <= {'0', '1'}):
+                            emit_at = now + interval  # One delayed reply to a rejected Trinity.
+                    else:
+                        # ================= LINCHPIN ================= #
+                        admissible = msg == step[state]
+                        # ============================================ #
+                        admitted = msg if admissible else None
+                    if admitted is not None:
+                        if not cube:
+                            state = admitted
+                            ready_at = emit_at = now + 1.0
+                        send(sock, total, admitted, index)
+                        show()
+            if len(seen) < total:
+                if len(seen) != shown_seen:
+                    show(f"{len(seen)} / {total}"); shown_seen = len(seen)
+                time.sleep(.05); continue
+            if ready_at == 0.0:
+                show(); ready_at = now + interval
+                if not cube: emit_at = ready_at
+                elif cube and cube.inverted: emit_at = emit_at or ready_at
+            active = (1 - mode) if (cube.inverted if cube else invert_mode) else mode
+            if cube:
+                if active and emit_at is not None and now >= emit_at:
+                    proposal = cube.propose()
+                    if proposal is not None: send(sock, total, proposal, index)
+                    emit_at = None  # One proposal per encounter; listen for another.
+            elif active and now >= ready_at and now >= emit_at:
+                send(sock, total, step[state], index)
+                emit_at = now + 1.0
+            ready, _, _ = select.select([sys.stdin], [], [], .05)
+            if ready:
+                key = os.read(sys.stdin.fileno(), 3)
+                if key == b" ": break
+                if key in (b"\x1b[A", b"\x1b[B"):
+                    mode = 1 - mode
+                    if cube:
+                        active = (1 - mode) if cube.inverted else mode
+                        emit_at = time.monotonic() + interval if active else None
+                    else:
+                        emit_at = time.monotonic() + 1.0
+                    show()
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        for s, h in handlers.items(): signal.signal(s, h)
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, old)
+        clear(); sock.close()
+
+def main():
+    index, total = map(int, sys.argv[1:3])
+    run(index, total)
+
+if __name__ == "__main__": main()

9volt-0.0.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: 9Volt
+Version: 0.0.1
+Summary: A tiny Oblivious Compute halting-machine specimen
+Requires-Python: >=3.10
+Requires-Dist: wcwidth>=0.2

9volt-0.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "9Volt"
+version = "0.0.1"
+description = "A tiny Oblivious Compute halting-machine specimen"
+requires-python = ">=3.10"
+dependencies = ["wcwidth>=0.2"]
+
+[project.scripts]
+HaltingMachine = "HaltingMachine:main"
+
+[tool.setuptools]
+py-modules = ["HaltingMachine"]
+packages = ["Machine"]

9volt-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

9volt-0.0.1/tests/test_display_feet.py

@@ -0,0 +1,85 @@
+"""Spacewalk's two pointers flank a centered four-shell icon strip."""
+import io
+import os
+import unittest
+from unittest.mock import patch
+from Machine.Spacewalk import Spacewalk, POSITIVE, NEGATIVE
+from Machine import observer
+
+
+class DisplayFeetTests(unittest.TestCase):
+    def test_previous_and_current_vertices_flank_four_icons(self):
+        for inverted, lane in ((False, POSITIVE), (True, NEGATIVE)):
+            node = Spacewalk(inverted)
+            for i in range(4):
+                top, middle, bottom = node.display()
+                self.assertEqual(node.previous, lane[max(0, i - 1)])
+                self.assertEqual(node.state, lane[i])
+                self.assertEqual(middle[:4], node.previous + ' ')
+                self.assertTrue(middle.endswith(' ' + node.state))
+                self.assertEqual(middle[4:-4], '🪨✂️ 📜🪨' if inverted else '🪨📜✂️ 🪨')
+                self.assertEqual(top, ' ' * (4 + 2 * i) + '🔻')
+                self.assertEqual(bottom, ' ' * (4 + 2 * i) + '🔺')
+                if i < 3:
+                    self.assertEqual(node.accept(node.propose()), lane[i + 1])
+
+    def test_doorway_reverses_icons_and_retains_last_vertex(self):
+        for old_inverted in (False, True):
+            node = Spacewalk(old_inverted)
+            for _ in range(3):
+                node.accept(node.propose())
+            self.assertEqual(node.state, '111')
+            self.assertEqual(node.doorway(), '000')
+            self.assertEqual(node.previous, '111')
+            self.assertEqual(node.inverted, not old_inverted)
+            top, middle, bottom = node.display()
+            self.assertTrue(middle.startswith('000 '))
+            self.assertTrue(middle.endswith(' 111'))
+            self.assertEqual(top, '    🔻')
+            self.assertEqual(bottom, '    🔺')
+            self.assertEqual(node.lane, POSITIVE if old_inverted else NEGATIVE)
+
+    def test_doorway_labels_reorient_without_mutating_internal_state(self):
+        for starting_inverted, first_step in ((False, '001'), (True, '100')):
+            node = Spacewalk(starting_inverted)
+            for _ in range(3): node.accept(node.propose())
+            node.doorway()
+            self.assertEqual((node.previous, node.state), ('111', '000'))
+            self.assertEqual(node.display()[1][:4], '000 ')
+            self.assertTrue(node.display()[1].endswith(' 111'))
+            self.assertEqual(node.accept(first_step), first_step)
+            self.assertTrue(node.display()[1].startswith('000 '))
+            self.assertTrue(node.display()[1].endswith(' ' + first_step))
+
+    def test_rejection_does_not_change_display(self):
+        node = Spacewalk()
+        first = node.display()
+        self.assertIsNone(node.accept('101'))
+        self.assertEqual(node.display(), first)
+
+    def test_terminal_alignment_in_both_orientations(self):
+        for inverted in (False, True):
+            node = Spacewalk(inverted)
+            for shell in range(4):
+                out = io.StringIO()
+                with patch.object(observer.sys, 'stdout', out), \
+                     patch.object(observer, 'paint'), \
+                     patch.object(observer.os, 'get_terminal_size',
+                                  return_value=os.terminal_size((80, 24))):
+                    observer.draw('Γ', 1 if inverted else 0, '🪨', inverted, cube=node)
+                lines = out.getvalue().splitlines()
+                icons = next(line for line in lines if '🪨' in line)
+                upper = next(line for line in lines if '🔻' in line)
+                lower = next(line for line in lines if '🔺' in line)
+                # Four columns for the previous Trinity + a space.
+                self.assertEqual(len(icons) - len(icons.lstrip(' ')), 32)
+                self.assertEqual(icons.index('🪨'), 36)
+                self.assertEqual(upper.index('🔻'), 36 + 2 * shell)
+                self.assertEqual(lower.index('🔺'), 36 + 2 * shell)
+                self.assertTrue(icons.rstrip().endswith(' ' + node.state))
+                if shell < 3:
+                    node.accept(node.propose())
+
+
+if __name__ == '__main__':
+    unittest.main()

9volt-0.0.1/tests/test_genesis_default.py

@@ -0,0 +1,22 @@
+"""Confirm the Genesis screen defaults, without launching real terminals."""
+import unittest
+from unittest.mock import patch
+from Machine import field
+
+class GenesisDefaultTest(unittest.TestCase):
+    def test_three_observers_one_inverter(self):
+        selections = []
+        def fake_choose(label, low, high, default):
+            selections.append((label, low, high, default))
+            return default
+        with patch.object(field, 'choose', side_effect=fake_choose), \
+             patch.object(field, 'spawn'), \
+             patch.object(field.random, 'randrange', return_value=0), \
+             patch('Machine.observer.run'), \
+             patch.object(field, 'clear'), \
+             patch.object(field.signal, 'signal'):
+            field.main()
+        self.assertEqual(selections[0], ('OBSERVERS', 1, 10, 3))
+        self.assertEqual(selections[1], ('INVERTERS', 0, 3, 1))
+
+if __name__ == '__main__': unittest.main()

9volt-0.0.1/tests/test_observer_wire.py

@@ -0,0 +1,139 @@
+"""V17: only expected-next admissions, repeating proposals, quiet doorways."""
+import unittest
+from unittest.mock import patch
+from Machine import observer, Spacewalk as cube_module
+
+class FakeSocket:
+    def __init__(self, clock, incoming):
+        self.clock, self.incoming, self.delivered = clock, incoming, set()
+    def setblocking(self, *_): pass
+    def bind(self, *_): pass
+    def close(self): pass
+    def recvfrom(self, *_):
+        t = self.clock[0]
+        if t in self.incoming and t not in self.delivered:
+            self.delivered.add(t)
+            return self.incoming[t].encode(), ('127.0.0.1', 9999)
+        raise BlockingIOError
+
+class WireTests(unittest.TestCase):
+    def execute(self, inverted=False, hypercube=True, inputs=None, stop=12,
+                arrow_at=None, arrows=None, interval=1.0):
+        clock, packets, snapshots, modes = [0], [], [], []
+        sock = FakeSocket(clock, {2:'H1', **(inputs or {})})
+        def tick():
+            clock[0] += 1
+            return float(clock[0])
+        def capture(_sock, _total, payload, _index):
+            packets.append((clock[0], payload))
+        def draw(_identity, mode, _state, face, genesis=None, cube=None):
+            if genesis is None:
+                modes.append((clock[0], mode, face))
+            if cube and genesis is None:
+                snapshots.append((clock[0], cube.state, cube.inverted, mode, face, cube.previous))
+        keys = arrows or ({arrow_at: b'\x1b[B'} if arrow_at is not None else {})
+        def ready(*_):
+            return ([0], [], []) if clock[0] >= stop or clock[0] in keys else ([], [], [])
+        def read(*_):
+            return keys.get(clock[0], b' ')
+        env = {'HALTING_SPACEWALK':'1'} if hypercube else {'HALTING_SPACEWALK':'0'}
+        # Older fixtures exercise the V26 one-second timing. Pass interval=None
+        # to test V27's actual configured three-second interval instead.
+        step = cube_module.INTERVAL if interval is None else interval
+        with patch.object(cube_module, 'INTERVAL', step), patch.dict('os.environ', env), \
+             patch.object(observer.socket, 'socket', return_value=sock), \
+             patch.object(observer.time, 'monotonic', side_effect=tick), \
+             patch.object(observer.select, 'select', side_effect=ready), \
+             patch.object(observer.termios, 'tcgetattr', return_value=[0]*7), \
+             patch.object(observer.termios, 'tcsetattr'), \
+             patch.object(observer.tty, 'setcbreak'), \
+             patch.object(observer.os, 'read', side_effect=read), \
+             patch.object(observer, 'draw', side_effect=draw), \
+             patch.object(observer, 'clear'), \
+             patch.object(observer, 'send', side_effect=capture), \
+             patch.object(observer.signal, 'signal'):
+            observer.run(0,2,step=observer.REVERSE if inverted else observer.FORWARD,
+                         invert_controls=inverted, invert_mode=inverted)
+        self.modes = modes
+        return [x for x in packets if not x[1].startswith('H')], snapshots
+
+    def test_original_healthy_wraps_and_physically_repeats_to_halt(self):
+        packets, snaps = self.execute(inputs={4:'100',6:'110',8:'111'})
+        self.assertEqual(packets[:3], [(4,'100'),(6,'110'),(8,'111')])
+        self.assertNotIn((8,'000'), packets)   # No extra same-window projection
+        self.assertNotIn((9,'000'), packets)  # Quiet entry to inverted cube
+        self.assertNotIn((10,'000'), packets)  # No periodic repeat after crossing
+        self.assertIn((9,'000',True,1,True,'111'), snaps)  # Inverted wiring: REPEAT is HALT
+        self.assertEqual(snaps[-1][2], True)
+
+    def test_original_inverter_unwraps_to_true_healthy_halt(self):
+        packets, snaps = self.execute(inverted=True, inputs={4:'001',6:'011',8:'111'})
+        self.assertIn((4,'001'), packets)
+        self.assertIn((6,'011'), packets)
+        self.assertIn((8,'111'), packets)
+        self.assertNotIn((9,'000'), packets)
+        self.assertNotIn((10,'000'), packets)  # Original inverter now effectively halted
+        self.assertIn((9,'000',False,0,False,'111'), snaps) # Actual physical HALT
+
+    def test_manual_repeat_after_doorway_uses_current_cube_wiring(self):
+        for original_inverter, path in ((False, ('000','100','110','111')),
+                                        (True, ('000','001','011','111'))):
+            data = {4:path[1], 6:path[2], 8:path[3]}
+            packets, snaps = self.execute(inverted=original_inverter, inputs=data,
+                                          arrow_at=10, stop=12)
+            self.assertNotIn((9,'000'), packets)  # Both doorway directions are silent
+            target = '100' if original_inverter else '001'
+            self.assertTrue(any(t>=11 and word==target for t,word in packets))
+            # Physical down => effective REPEAT using the *current* wrapper.
+            self.assertTrue(any(s[1:] == ('000', not original_inverter,
+                               1 if original_inverter else 0,
+                               not original_inverter, '111') for s in snaps))
+
+    def test_double_doorway_rewraps_and_unwraps_for_both_origins(self):
+        # Include both complete 3-edge walks to exercise wrap -> unwrap.
+        for original_inverter, first, second in (
+            (False, ('000','100','110'), ('000','001','011')),
+            (True, ('000','001','011'), ('000','100','110')),
+        ):
+            timeline = dict(zip((4,6,8,10,12,14), first[1:] + ('111',) + second[1:] + ('111',)))
+            packets, snaps = self.execute(inverted=original_inverter, inputs=timeline,
+                                          stop=18)
+            self.assertIn((9,'000',not original_inverter,
+                           int(not original_inverter),not original_inverter,'111'), snaps)
+            self.assertIn((15,'000',original_inverter,
+                           int(original_inverter),original_inverter,'111'), snaps)
+            self.assertIn((8,'111'), packets)
+            self.assertIn((14,'111'), packets)
+            # Active inverter may also PROPOSE 111 ahead of its acceptance.
+            if original_inverter:
+                self.assertIn((7,'111'), packets)
+            # The final machine genuinely has its original, restored
+            # physical HALT/REPEAT interpretation and remains silent.
+            self.assertNotIn((16,'000'), packets)
+            self.assertNotIn((17,'000'), packets)
+
+    def test_repeat_proposes_without_self_transition_and_waits_for_echo(self):
+        # Manual REPEAT at t=3, proposal at t=5, no incoming echo until t=8.
+        packets, snaps = self.execute(inputs={8:'100'}, arrow_at=3, stop=11)
+        first_proposal = next(t for t,p in packets if p=='100')
+        self.assertLess(first_proposal,8)
+        self.assertFalse(any(t<8 and st!='000' for t,st,*_ in snaps))
+        self.assertTrue(any(t==8 and st=='100' for t,st,*_ in snaps))
+        self.assertIn((8,'100'), packets)  # reprojects only upon admission
+
+    def test_plain_mode_inverter_still_uses_original_reverse_cycle(self):
+        packets, snaps = self.execute(hypercube=False, inverted=True,
+                                      inputs={4:observer.SCISSORS})
+        self.assertIn((4, observer.SCISSORS), packets)
+        self.assertFalse(snaps)
+
+    def test_plain_mode_inverter_repeat_mapping_is_unchanged(self):
+        packets, _ = self.execute(hypercube=False, inverted=True, stop=10)
+        self.assertTrue(any(payload == observer.SCISSORS for _,payload in packets))
+
+    def test_plain_mode_still_admits_old_expected_rps(self):
+        packets, snaps = self.execute(hypercube=False, inputs={4:observer.PAPER})
+        self.assertIn((4,observer.PAPER), packets)
+        self.assertFalse(snaps)
+
+if __name__ == '__main__': unittest.main()

9volt-0.0.1/tests/test_trinity.py

@@ -0,0 +1,66 @@
+"""Deterministic regression checks for Trinity geometry and admission."""
+import unittest
+from Machine.Spacewalk import Spacewalk, POSITIVE, NEGATIVE, LATERAL
+
+class TrinityTests(unittest.TestCase):
+    def test_all_eight_vertices_covered_exactly_once(self):
+        self.assertEqual(set(POSITIVE) & set(NEGATIVE), {'000', '111'})
+        self.assertEqual((set(POSITIVE) | set(NEGATIVE)) & LATERAL, set())
+        self.assertEqual((set(POSITIVE) | set(NEGATIVE)) | LATERAL,
+                         {f'{x:03b}' for x in range(8)})
+        self.assertEqual(LATERAL, {'010', '101'})
+
+    def test_each_path_has_only_valid_one_bit_edges(self):
+        for lane in (POSITIVE, NEGATIVE):
+            self.assertEqual([sum(a != b for a, b in zip(u, v))
+                              for u,v in zip(lane, lane[1:])], [1,1,1])
+            self.assertEqual([s.count('1') for s in lane], [0,1,2,3])
+
+    def test_mirror(self):
+        self.assertEqual(tuple(s[::-1] for s in POSITIVE), NEGATIVE)
+
+    def test_matching_state_is_inert_and_proposal_has_no_side_effect(self):
+        for inverted, expected in ((False, POSITIVE), (True, NEGATIVE)):
+            node = Spacewalk(inverted)
+            for vertex in expected[1:]:
+                current = node.state
+                self.assertIsNone(node.accept(current))
+                self.assertEqual(node.state, current)
+                self.assertEqual(node.propose(), vertex)
+                self.assertEqual(node.state, current)  # proposal != admission
+                self.assertEqual(node.accept(vertex), vertex)
+                self.assertEqual(node.state, vertex)
+            self.assertIsNone(node.propose())
+            self.assertIsNone(node.accept('111'))
+            self.assertEqual(node.state, '111')
+
+    def test_expected_successor_admitted(self):
+        for inverted, path in ((False, POSITIVE), (True, NEGATIVE)):
+            node = Spacewalk(inverted)
+            for vertex in path[1:]:
+                self.assertEqual(node.accept(vertex), vertex)
+
+    def test_off_lane_including_lateral_is_rejected(self):
+        for inverted in (False, True):
+            node = Spacewalk(inverted)
+            for packet in ('010','101','xyz','111','1000'):
+                self.assertIsNone(node.accept(packet))
+                self.assertEqual(node.state,'000')
+
+    def test_no_sender_orientation_is_transmitted(self):
+        self.assertEqual(Spacewalk(False).state, Spacewalk(True).state)
+        self.assertEqual(Spacewalk(False).state, '000')
+
+    def test_four_shell_emblems_switch_and_one_dot(self):
+        a,b = Spacewalk(), Spacewalk(True)
+        self.assertEqual(a.display()[1].count('📜'),1)
+        self.assertEqual(b.display()[1].count('📜'),1)
+        self.assertNotEqual(a.display()[1],b.display()[1])
+        for node in (a,b):
+            for i in range(4):
+                self.assertEqual(node.shell,i)
+                self.assertEqual(node.display()[0].count('🔻'),1)
+                self.assertEqual(node.display()[2].count('🔺'),1)
+                if node.propose() is not None: node.accept(node.propose())
+
+if __name__=='__main__': unittest.main()

9volt-0.0.1/tests/test_v22_timing.py

@@ -0,0 +1,31 @@
+"""Regression: no flickering startup loop or endlessly deferred proposals."""
+import unittest
+import test_observer_wire as wire
+
+
+class SpacewalkTimingTests(unittest.TestCase):
+    def test_halted_spacewalk_renders_once_at_startup(self):
+        data, snapshots = wire.WireTests().execute(stop=14)
+        self.assertEqual(data, [])
+        self.assertEqual(len(snapshots), 1)
+
+    def test_inverter_initial_proposal_then_listens_until_next_encounter(self):
+        data, snapshots = wire.WireTests().execute(inverted=True, stop=14)
+        self.assertEqual(len(snapshots), 1)
+        self.assertEqual(data, [(3, '001')])
+
+    def test_healthy_manual_repeat_perturbs_field_once_and_listens(self):
+        data, snapshots = wire.WireTests().execute(arrow_at=3, stop=14)
+        self.assertEqual(data, [(5, '100')])
+        self.assertEqual({state for _, state, *_ in snapshots}, {'000'})
+
+    def test_admissions_do_not_wait_for_one_second_in_spacewalk(self):
+        data, snapshots = wire.WireTests().execute(inputs={4: '100', 5: '110', 6: '111'}, stop=11)
+        admissions = [(t, state) for t, state, *_ in snapshots if state != '000']
+        self.assertEqual(admissions[:3], [(4, '100'), (5, '110'), (6, '111')])
+        self.assertIn((5, '110'), data)
+        self.assertIn((6, '111'), data)
+
+
+if __name__ == '__main__':
+    unittest.main()

9volt-0.0.1/tests/test_v23_layout.py

@@ -0,0 +1,43 @@
+"""Keep original RPS spacing independent from Spacewalk's compact layout."""
+import io
+import os
+import unittest
+from unittest.mock import patch
+from Machine import observer
+from Machine.Spacewalk import Spacewalk
+
+class LayoutTests(unittest.TestCase):
+    def render(self, cube):
+        capture = io.StringIO()
+        with patch.object(observer.sys, 'stdout', capture), \
+             patch.object(observer, 'paint'), \
+             patch.object(observer.os, 'get_terminal_size',
+                          return_value=os.terminal_size((80, 24))):
+            observer.draw('Γ', 0, observer.ROCK, cube=cube)
+        return capture.getvalue().splitlines()
+
+    def test_both_modes_shift_two_lines_down_as_one_cluster(self):
+        for cube in (None, Spacewalk(), Spacewalk(True)):
+            lines = self.render(cube)
+            title = next(i for i, line in enumerate(lines) if 'HaltingMachine' in line)
+            self.assertEqual(title, 4)  # V27 started at line index 2.
+            self.assertEqual(lines[:4], ['', '', '', ''])
+
+    def test_plain_layout_has_both_original_blank_rows(self):
+        lines = self.render(None)
+        repeat = next(i for i,line in enumerate(lines) if line.strip() == 'REPEAT')
+        self.assertEqual(lines[repeat + 1], '')
+        self.assertIn(observer.ROCK * 4, lines[repeat + 2])
+        self.assertEqual(lines[repeat + 3], '')
+        self.assertIn('SPACE TO EXIT', lines[repeat + 4])
+
+    def test_spacewalk_has_no_blank_rows_between_controls_and_exit(self):
+        lines = self.render(Spacewalk())
+        repeat = next(i for i,line in enumerate(lines) if line.strip() == 'REPEAT')
+        self.assertIn('🔻', lines[repeat + 1])
+        self.assertIn('🪨', lines[repeat + 2])
+        self.assertIn('🔺', lines[repeat + 3])
+        self.assertIn('SPACE TO EXIT', lines[repeat + 4])
+        self.assertNotIn('', lines[repeat + 1:repeat + 5])
+
+if __name__ == '__main__': unittest.main()

9volt-0.0.1/tests/test_v24_cadence.py

@@ -0,0 +1,52 @@
+"""V26: each admissibility encounter can re-arm a one-shot repeater."""
+import unittest
+import test_observer_wire as wire
+from Machine import observer
+
+
+class CadenceTests(unittest.TestCase):
+    def test_inadmissible_trinity_resets_emission_without_changing_state(self):
+        packets, snapshots = wire.WireTests().execute(
+            inverted=True, inputs={4: '111', 5: '111', 6: '111'}, stop=10)
+        proposal_times = [t for t, msg in packets if msg == '001']
+        self.assertEqual(proposal_times[:3], [3, 5, 7])
+        self.assertEqual({state for _, state, *_ in snapshots}, {'000'})
+        self.assertEqual(len(snapshots), 1)  # no redraw on rejection
+
+    def test_idempotent_and_lateral_trinity_also_regulate_cadence(self):
+        packets, snapshots = wire.WireTests().execute(
+            inverted=True, inputs={4: '000', 5: '010', 6: '101'}, stop=10)
+        self.assertEqual([t for t, msg in packets if msg == '001'][:3], [3, 5, 7])
+        self.assertEqual({state for _, state, *_ in snapshots}, {'000'})
+
+    def test_discovery_packets_do_not_regulate_cadence(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, inputs={4: 'H1', 5: 'H1', 6: 'H1'}, stop=10)
+        self.assertEqual([t for t, msg in packets if msg == '001'], [3])
+
+    def test_nontrinity_payload_does_not_regulate_cadence(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, inputs={4: 'xyz', 5: '1000', 6: 'bad'}, stop=10)
+        self.assertEqual([t for t, msg in packets if msg == '001'], [3])
+
+    def test_no_ongoing_repeater_without_a_new_trinity(self):
+        packets, _ = wire.WireTests().execute(inverted=True, inputs={4:'111'}, stop=20)
+        self.assertEqual([t for t, msg in packets if msg == '001'], [3, 5])
+
+    def test_original_haltingmachine_is_unchanged_by_inadmissible_packets(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, hypercube=False,
+            inputs={4: observer.ROCK, 5: observer.ROCK, 6: observer.ROCK}, stop=10)
+        self.assertEqual([t for t, msg in packets if msg == observer.SCISSORS][:3],
+                         [3, 4, 5])
+
+    def test_admitted_trinity_reprojects_immediately_without_admission_gate(self):
+        packets, snapshots = wire.WireTests().execute(
+            inputs={4:'100', 5:'110', 6:'111'}, stop=9)
+        self.assertEqual([(t, state) for t,state,*_ in snapshots if state != '000'],
+                         [(4,'100'), (5,'110'), (6,'111')])
+        self.assertIn((5, '110'), packets)
+
+
+if __name__ == '__main__':
+    unittest.main()

9volt-0.0.1/tests/test_v25_toggle_and_pacing.py

@@ -0,0 +1,48 @@
+"""V26 one-shot reception pacing, original physical switches, and spacing."""
+import io
+import os
+import unittest
+from unittest.mock import patch
+from Machine import observer
+from Machine.Spacewalk import Spacewalk
+import test_observer_wire as wire
+
+
+class V25Tests(unittest.TestCase):
+    def test_receiving_every_tick_cannot_starve_inverter(self):
+        stream = {t: '111' for t in range(4, 21)}
+        packets, snapshots = wire.WireTests().execute(
+            inverted=True, inputs=stream, stop=22)
+        times = [t for t, payload in packets if payload == '001']
+        self.assertGreaterEqual(len(times), 8, times)
+        self.assertEqual(times[:4], [3,5,7,9])
+        self.assertEqual({state for _,state,*_ in snapshots}, {'000'})
+
+    def test_one_response_per_packet_window_then_listen(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, inputs={4:'111', 5:'111', 6:'111', 7:'111'}, stop=11)
+        self.assertEqual([t for t,p in packets if p=='001'], [3,5,7])
+
+    def test_arrows_wrap_both_physical_controls_in_both_modes(self):
+        for inverted in (False, True):
+            for cube in (False, True):
+                for arrow in (b'\x1b[A', b'\x1b[B'):
+                    test = wire.WireTests()
+                    test.execute(inverted=inverted, hypercube=cube, stop=8,
+                                 arrows={4:arrow, 6:arrow})
+                    toggles = [mode for _,mode,_ in test.modes]
+                    self.assertEqual(toggles, [0,1,0])
+
+    def test_plain_exit_text_shifted_one_column_spacewalk_unchanged(self):
+        def render(cube):
+            out = io.StringIO()
+            with patch.object(observer.sys, 'stdout', out), patch.object(observer, 'paint'), \
+                 patch.object(observer.os,'get_terminal_size', return_value=os.terminal_size((80,24))):
+                observer.draw('Γ',0,observer.ROCK,cube=cube)
+            return next(l for l in out.getvalue().splitlines() if 'SPACE TO EXIT' in l)
+        plain = render(None)
+        spacewalk = render(Spacewalk())
+        self.assertEqual(plain, spacewalk)
+        self.assertEqual(len(plain)-len(plain.lstrip()), 34)
+
+if __name__ == '__main__': unittest.main()

9volt-0.0.1/tests/test_v26_pingpong.py

@@ -0,0 +1,46 @@
+"""V26: each active repeater earns one delayed proposal per encounter."""
+import unittest
+import test_observer_wire as wire
+
+
+class PingPongTests(unittest.TestCase):
+    def test_halted_relay_never_proposes_from_rejected_packets(self):
+        packets, frames = wire.WireTests().execute(
+            inputs={4:'001',5:'111',6:'010'}, stop=11)
+        self.assertEqual(packets, [])
+        self.assertEqual({state for _,state,*_ in frames}, {'000'})
+        self.assertEqual(len(frames), 1)
+
+    def test_halted_relay_admits_each_successor_without_a_timer(self):
+        packets, frames = wire.WireTests().execute(
+            inputs={4:'100',5:'110',6:'111'}, stop=13)
+        self.assertEqual(packets, [(4,'100'),(5,'110'),(6,'111')])
+        self.assertEqual([st for _,st,*_ in frames][:4],
+                         ['000','100','110','111'])
+
+    def test_repeater_admission_echoes_immediately_and_resets_timer(self):
+        packets, frames = wire.WireTests().execute(
+            inverted=True, inputs={4:'001',5:'011'}, stop=12)
+        self.assertEqual(packets, [(3,'001'),(4,'001'),(5,'011'),(6,'111')])
+        self.assertEqual([st for _,st,*_ in frames], ['000','001','011'])
+
+    def test_admission_starts_one_proposal_even_without_another_packet(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, inputs={4:'001'}, stop=12)
+        self.assertEqual(packets, [(3,'001'),(4,'001'),(5,'011')])
+
+    def test_multiple_rejections_in_same_window_do_not_restart_countdown(self):
+        packets, frames = wire.WireTests().execute(
+            inverted=True, inputs={4:'000',5:'000'}, stop=12)
+        self.assertEqual(packets, [(3,'001'),(5,'001')])
+        self.assertEqual(len(frames), 1)
+
+    def test_manual_perturbation_speaks_once_then_admission_drives_next(self):
+        packets, frames = wire.WireTests().execute(
+            arrow_at=3, inputs={6:'100',7:'110'}, stop=12)
+        self.assertEqual(packets, [(5,'100'),(6,'100'),(7,'110'),(8,'111')])
+        self.assertEqual([st for _,st,*_ in frames], ['000','000','100','110'])
+
+
+if __name__ == '__main__':
+    unittest.main()

9volt-0.0.1/tests/test_v27_three_seconds.py

@@ -0,0 +1,58 @@
+"""V27 ships a 3-second Spacewalk interval without touching RPS or admission."""
+import unittest
+from Machine.Spacewalk import Spacewalk, INTERVAL
+from Machine import observer
+import test_observer_wire as wire
+
+
+class ThreeSecondTests(unittest.TestCase):
+    def test_pace_is_three_seconds(self):
+        self.assertEqual(INTERVAL, 3.0)
+
+    def test_doorway_wait_is_three_seconds_from_admission(self):
+        for inverted, lane in ((False, ('100', '110', '111')),
+                               (True, ('001', '011', '111'))):
+            walk = Spacewalk(inverted)
+            for t, vertex in enumerate(lane, start=4):
+                self.assertEqual(walk.accept(vertex, now=t), vertex)
+            self.assertEqual(walk.doorway_at, 6.0 + INTERVAL)
+            self.assertEqual(walk.state, '111')
+
+    def test_first_inverted_proposal_is_after_three_seconds(self):
+        packets, frames = wire.WireTests().execute(inverted=True, stop=12, interval=None)
+        self.assertEqual(packets, [(5, '001')])
+        self.assertEqual(len(frames), 1)
+
+    def test_manual_repeat_waits_three_seconds_then_listens(self):
+        packets, frames = wire.WireTests().execute(arrow_at=3, stop=12, interval=None)
+        self.assertEqual(packets, [(7, '100')])
+        self.assertTrue(all(st == '000' for _, st, *_ in frames))
+
+    def test_rejected_packet_arms_one_response_and_does_not_keep_postponing(self):
+        packets, frames = wire.WireTests().execute(
+            inverted=True, inputs={4: '000', 6: '111', 7: '010'}, stop=13, interval=None)
+        self.assertEqual(packets, [(5, '001'), (9, '001')])
+        self.assertEqual({state for _, state, *_ in frames}, {'000'})
+
+    def test_admission_echo_immediate_and_restarts_three_second_timer(self):
+        packets, frames = wire.WireTests().execute(
+            inverted=True, inputs={4: '001', 5: '011'}, stop=12, interval=None)
+        self.assertEqual(packets, [(4, '001'), (5, '011'), (8, '111')])
+        self.assertEqual([state for _,state,*_ in frames], ['000', '001', '011'])
+
+    def test_halted_relay_still_admits_immediately_and_crosses_in_three_seconds(self):
+        packets, frames = wire.WireTests().execute(
+            inputs={4: '100', 5: '110', 6: '111'}, stop=13, interval=None)
+        self.assertEqual(packets, [(4, '100'), (5, '110'), (6, '111')])
+        self.assertIn((9, '000', True, 1, True, '111'), frames)
+
+    def test_plain_rps_still_uses_one_second_timer(self):
+        packets, _ = wire.WireTests().execute(
+            inverted=True, hypercube=False, stop=9, interval=None)
+        self.assertEqual(packets[:3], [(3, observer.SCISSORS),
+                                        (4, observer.SCISSORS),
+                                        (5, observer.SCISSORS)])
+
+
+if __name__ == '__main__':
+    unittest.main()