web-a2e 1.0.0

package/docs/softswitch-comparison.md

@@ -0,0 +1,273 @@
+# Softswitch Implementation Comparison: web-a2e vs AppleWin
+
+This document compares the softswitch handling between web-a2e and AppleWin (the reference Apple II emulator).
+
+## Architecture Overview
+
+| Aspect | web-a2e | AppleWin |
+|--------|---------|----------|
+| **Structure** | Single `SoftSwitches` struct with ~30 boolean flags in `types.hpp`, centralized handling in `MMU::readSoftSwitch()` / `writeSoftSwitch()` | Bitmask `g_memmode` with flags (`MF_80STORE`, `MF_AUXREAD`, etc.), distributed across IO handler functions |
+| **Dispatch** | Single large `switch` statement on `(address & 0xFF)` | Function pointer array (`IORead[8]`, `IOWrite[8]`) dispatching to `IORead_C0xx()` / `IOWrite_C0xx()` handlers |
+| **Memory Model** | Direct boolean flags accessed via `switches_.xxx` | Bitfield operations: `SetMemMode(g_memmode | MF_FLAG)` |
+
+## I/O Dispatch Mechanism
+
+### AppleWin Approach
+
+AppleWin uses function pointer arrays split by $10 address ranges:
+
+```cpp
+static iofunction IORead_C0xx[8] = {
+    IORead_C00x,  // Keyboard
+    IORead_C01x,  // Memory/Video status
+    IORead_C02x,  // Cassette
+    IORead_C03x,  // Speaker
+    IORead_C04x,  // Unused
+    IORead_C05x,  // Video mode switches
+    IORead_C06x,  // Joystick
+    IORead_C07x,  // Joystick/Video
+};
+```
+
+Each handler function processes 16 addresses:
+
+```cpp
+static BYTE __stdcall IORead_C01x(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
+{
+    bool res = false;
+    switch (addr & 0xf)
+    {
+    case 0x0: return KeybReadFlag();
+    case 0x1: res = SW_BANK2 ? true : false; break;
+    case 0x2: res = SW_HIGHRAM ? true : false; break;
+    // ...
+    }
+    return KeybGetKeycode() | (res ? 0x80 : 0);
+}
+```
+
+### web-a2e Approach
+
+web-a2e uses a monolithic switch in `mmu.cpp`:
+
+```cpp
+uint8_t MMU::readSoftSwitch(uint16_t address) {
+    uint8_t reg = address & 0xFF;
+    switch (reg) {
+    case 0x00: return keyboardLatch_;
+    case 0x10: keyboardLatch_ &= 0x7F; return keyboardLatch_;
+    case 0x11: return (switches_.lcram2 ? 0x80 : 0x00) | (getFloatingBusValue() & 0x7F);
+    // ... all 256 cases
+    }
+}
+```
+
+**Trade-offs:**
+- AppleWin: Better code organization, easier to maintain per-device handlers
+- web-a2e: Simpler dispatch, all logic visible in one place
+
+## Status Read Return Values ($C01x)
+
+Both implementations return the switch state in bit 7 with data bus noise in bits 0-6.
+
+### AppleWin
+
+Returns the last keyboard keycode OR'd with the status bit:
+
+```cpp
+return KeybGetKeycode() | (res ? 0x80 : 0);
+```
+
+### web-a2e
+
+Returns floating bus value OR'd with the status bit:
+
+```cpp
+return (switches_.lcram2 ? 0x80 : 0x00) | (getFloatingBusValue() & 0x7F);
+```
+
+Both approaches are correct per "Understanding the Apple IIe" (UTAIIe) - the lower 7 bits represent data bus noise from the previous cycle.
+
+## Memory Paging Updates
+
+### AppleWin
+
+AppleWin maintains shadow memory arrays for fast access:
+
+```cpp
+LPBYTE memshadow[256];  // Read pointers per 256-byte page
+LPBYTE memwrite[256];   // Write pointers per 256-byte page
+BYTE memdirty[256];     // Dirty flags for copy-back
+```
+
+When a paging mode changes, `UpdatePaging()` copies memory between shadow regions:
+
+```cpp
+if ((lastmemmode != g_memmode) || modechanging)
+{
+    for (UINT page = 0; page < 256; page++)
+    {
+        if (oldshadow[page] != memshadow[page])
+        {
+            if (*(memdirty+page) & 1)
+                memcpy(oldshadow[page], mem+(page << 8), 256);
+            memcpy(mem+(page << 8), memshadow[page], 256);
+        }
+    }
+}
+```
+
+### web-a2e
+
+web-a2e evaluates switches at memory access time without shadow caching:
+
+```cpp
+// In read() method
+if (switches_.store80 && switches_.page2) {
+    return auxMemory_[address];
+}
+if (switches_.ramrd) {
+    return auxMemory_[address];
+}
+return mainMemory_[address];
+```
+
+**Trade-offs:**
+- AppleWin: Faster memory access after mode change (direct pointer dereference)
+- web-a2e: Simpler implementation, no synchronization overhead, but more conditionals per access
+
+## Language Card Handling ($C080-$C08F)
+
+### AppleWin
+
+Delegates to a separate `LanguageCard` class that manages:
+- Bank selection (bank 1 vs bank 2)
+- Read source (RAM vs ROM)
+- Write enable state with pre-write tracking
+
+### web-a2e
+
+Handles inline in `handleLanguageCardSwitch()`:
+
+```cpp
+uint8_t MMU::handleLanguageCardSwitch(uint8_t reg) {
+    bool bank2 = !(reg & 0x08);
+    uint8_t op = reg & 0x03;
+    bool readRAM = (op == 0 || op == 3);
+
+    switch (op) {
+    case 0: // $C080, $C088: Read RAM, write disabled
+        switches_.lcwrite = false;
+        switches_.lcprewrite = false;
+        break;
+    case 1: // $C081, $C089: Read ROM, write enable on second read
+        if (switches_.lcprewrite) {
+            switches_.lcwrite = true;
+        }
+        switches_.lcprewrite = true;
+        break;
+    // ...
+    }
+    switches_.lcram = readRAM;
+    switches_.lcram2 = bank2;
+    return getFloatingBusValue();
+}
+```
+
+Both implementations correctly handle the double-read requirement for write enable.
+
+## Annunciators ($C058-$C05F)
+
+### AppleWin
+
+Has special handling for DHIRES that checks machine type and IOUDIS state:
+
+```cpp
+static BYTE __stdcall IOReadWrite_ANx(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
+{
+    if (IsAppleIIeOrAbove(GetApple2Type()))
+    {
+        if (!IsAppleIIc(GetApple2Type()) || SW_IOUDIS)
+            GetVideo().VideoSetMode(pc, addr, bWrite, d, nExecutedCycles);
+    }
+    if (IsAppleIIc(GetApple2Type()))
+        return 0;  // No ANx lines for //c
+    return IO_Annunciator(pc, addr, bWrite, d, nExecutedCycles);
+}
+```
+
+### web-a2e
+
+Directly sets annunciator flags without DHIRES coupling:
+
+```cpp
+case 0x5E:
+    switches_.an3 = false;
+    return getFloatingBusValue();  // AN3 OFF = DHIRES enabled
+case 0x5F:
+    switches_.an3 = true;
+    return getFloatingBusValue();  // AN3 ON = DHIRES disabled
+```
+
+The DHIRES state is derived from AN3 when needed rather than tracked separately.
+
+## Potential Issues in web-a2e
+
+### 1. $C000-$C00B Read Behavior
+
+web-a2e treats $C000 as the only keyboard read address. AppleWin's `IORead_C00x` returns keyboard data for the entire `$C000-$C00F` range, which matches hardware behavior where the keyboard decoder responds to all 16 addresses.
+
+**Current web-a2e code:**
+```cpp
+case 0x00: return keyboardLatch_;
+case 0x01: case 0x02: ... case 0x0F: return getFloatingBusValue();
+```
+
+**Should be:**
+```cpp
+case 0x00: case 0x01: case 0x02: ... case 0x0F:
+    return keyboardLatch_;
+```
+
+### 2. Write-Only Switch Reads ($C000-$C00B)
+
+AppleWin returns keyboard data when reading write-only memory switches. web-a2e returns floating bus, which may cause compatibility issues with software that reads these addresses expecting keyboard data.
+
+### 3. PAGE2/HIRES and Memory Remapping
+
+AppleWin routes $C054-$C057 through `MemSetPaging()` which triggers `UpdatePaging()` to remap memory pointers. web-a2e sets switches but relies on runtime evaluation. This is functionally equivalent but should be verified for timing-sensitive software.
+
+### 4. 80STORE/PAGE2 Interaction
+
+AppleWin explicitly updates memory mappings when PAGE2 changes and 80STORE is set:
+
+```cpp
+if (SW_80STORE)
+{
+    for (loop = 0x04; loop < 0x08; loop++)
+    {
+        memshadow[loop] = SW_PAGE2 ? memaux+(loop << 8) : memmain+(loop << 8);
+        memwrite[loop] = mem+(loop << 8);
+    }
+}
+```
+
+web-a2e checks `store80 && page2` at read/write time, which is functionally equivalent but potentially slower for tight loops.
+
+## Summary
+
+| Feature | web-a2e | AppleWin |
+|---------|---------|----------|
+| Code clarity | Better - all logic in one switch | Distributed across handlers |
+| Performance | Slower - runtime switch evaluation | Faster - pointer tables |
+| Machine support | IIe focused | II, II+, IIe, IIc, IIgs |
+| Memory model | Direct evaluation | Shadow page tables |
+| Maintainability | Easier - single file | Harder - multiple classes |
+
+web-a2e's implementation is cleaner and more readable with the struct-based approach, while AppleWin is more optimized for performance with its paged shadow memory and function pointer dispatch. Both correctly implement the core Apple IIe softswitch semantics.
+
+## References
+
+- AppleWin source: https://github.com/AppleWin/AppleWin/blob/master/source/Memory.cpp
+- "Understanding the Apple IIe" by James Sather (UTAIIe)
+- Apple IIe Technical Reference Manual

package/docs/thunderclock-debug.md

@@ -0,0 +1,89 @@
+# Thunderclock Debug Notes
+
+## Current Status
+
+- ProDOS **detects** the clock card (MACHID bit 0 is set)
+- But new files show `<NO DATE>` - time data isn't being read correctly
+- The serial protocol implementation likely needs adjustment
+
+## Verification Commands (ProDOS BASIC)
+
+### Check if clock was detected
+```
+PRINT PEEK(49048)
+```
+- Odd number = clock detected (bit 0 set)
+- Result was **179** - clock IS detected
+
+### Check clock driver hook
+```
+PRINT PEEK(49926)
+```
+- 76 ($4C) = JMP, clock driver installed
+- 96 ($60) = RTS, no clock driver
+- Result was **144** ($90) - unexpected value
+
+### Test I/O register (slot 5)
+```
+PRINT PEEK(49360)
+```
+- Reads $C0D0 (Thunderclock I/O for slot 5)
+- Result was **0** - card is responding
+
+## Manual Serial Protocol Test
+
+Run these in order to test if the Thunderclock responds to the serial protocol:
+
+### Step 1 - Trigger time read (STROBE + CMD_TIMED)
+```
+POKE 49360, 164
+```
+($A4 = CMD_TIMED $A0 | STROBE $04)
+
+### Step 2 - Clock out first data bit
+```
+POKE 49360, 162
+```
+($A2 = CMD_TIMED $A0 | CLOCK $02)
+
+### Step 3 - Read the result
+```
+PRINT PEEK(49360)
+```
+- If bit 7 is set: value >= 128
+- If bit 7 is clear: value < 128
+- This tells us if data bits are being shifted out
+
+### Step 4 - Clock out more bits and check pattern
+Repeat steps 2-3 multiple times to see if different bits come out:
+```
+POKE 49360, 160: POKE 49360, 162: PRINT PEEK(49360)
+POKE 49360, 160: POKE 49360, 162: PRINT PEEK(49360)
+POKE 49360, 160: POKE 49360, 162: PRINT PEEK(49360)
+```
+(Each line: clear clock, set clock, read bit)
+
+## Expected Time Format
+
+The Thunderclock outputs 40 bits in this order (MSB first):
+1. Month (4 bits) - 0-11
+2. Day of week (4 bits) - 0-6, Sunday=0
+3. Day of month (8 bits BCD)
+4. Hour (8 bits BCD, 24-hour)
+5. Minute (8 bits BCD)
+6. Second (8 bits BCD)
+
+## Memory Addresses Reference
+
+| Address | Decimal | Purpose |
+|---------|---------|---------|
+| $C0D0 | 49360 | Slot 5 I/O register |
+| $C500 | 50432 | Slot 5 ROM start |
+| $BF98 | 49048 | ProDOS MACHID |
+| $BF06 | 49926 | ProDOS clock hook |
+
+## Files
+
+- `src/core/cards/thunderclock_card.cpp` - Serial protocol implementation
+- `src/core/cards/thunderclock_card.hpp` - Card class definition
+- `roms/Thunderclock Plus ROM.bin` - Real Thunderclock ROM (2KB)

package/examples/cube.bas

@@ -0,0 +1,72 @@
+10 HGR : HGR2
+12 SZ = 150 : CX = 140 : CY = 96
+15 SC = 0
+18 ANGLE = 0
+20 DIM PTS(7,2)
+25 DIM RZP(7,2) : DIM RYP(7,2) : DIM RXP(7,2)
+27 DIM PRJ(7,2)
+30 GOSUB 5000
+
+100 REM DRAW LOOP
+105 CALL 62450
+110 GOSUB 2000 : REM ROTATE POINTS
+120 GOSUB 6000 : REM LINES
+140 ANGLE = ANGLE + 0.1
+150 GOSUB 1000
+160 GOTO 100
+
+500 X1 = PRJ(A,0) * SZ + CX
+510 Y1 = PRJ(A,1) * SZ + CY
+520 X2 = PRJ(B,0) * SZ + CX
+530 Y2 = PRJ(B,1) * SZ + CY
+535 HCOLOR=3
+540 HPLOT X1,Y1 TO X2,Y2
+550 RETURN
+
+1000 SC = NOT SC
+1010 POKE 49236 + NOT SC,0
+1020 POKE 230,32 + 32 * SC
+1030 RETURN
+
+2000 CS = COS(ANGLE)
+2010 SN = SIN(ANGLE)
+2020 FOR N = 0 TO 7
+2030 RZP(N,0) = -CS * PTS(N,0) + SN * PTS(N,1) +  0 * PTS(N,2)
+2040 RZP(N,1) =  SN * PTS(N,0) + CS * PTS(N,1) +  0 * PTS(N,2)
+2050 RZP(N,2) =   0 * PTS(N,0) +  0 * PTS(N,1) +  1 * PTS(N,2)
+2060 RYP(N,0) =  CS * RZP(N,0) +  0 * RZP(N,1) + SN * RZP(N,2)
+2070 RYP(N,1) =   0 * RZP(N,0) +  1 * RZP(N,1) +  0 * RZP(N,2)
+2080 RYP(N,2) = -SN * RZP(N,0) +  0 * RZP(N,1) + CS * RZP(N,2)
+2090 RXP(N,0) =  RYP(N,0)
+2100 RXP(N,1) =  CS * RYP(N,1) - SN * RYP(N,2)
+2110 RXP(N,2) =  SN * RYP(N,1) + CS * RYP(N,2)
+2120 Z = 1 / (5 - RXP(N,2))
+2130 PRJ(N,0) = RXP(N,0) * Z
+2140 PRJ(N,1) = RXP(N,1) * Z
+2150 NEXT N
+2160 RETURN
+
+5000 PTS(0,0) = -1: PTS(0,1) = -1 : PTS(0,2) = -1
+5010 PTS(1,0) =  1: PTS(1,1) = -1 : PTS(1,2) = -1
+5020 PTS(2,0) =  1: PTS(2,1) =  1 : PTS(2,2) = -1
+5030 PTS(3,0) = -1: PTS(3,1) =  1 : PTS(3,2) = -1
+5040 PTS(4,0) = -1: PTS(4,1) = -1 : PTS(4,2) =  1
+5050 PTS(5,0) =  1: PTS(5,1) = -1 : PTS(5,2) =  1
+5060 PTS(6,0) =  1: PTS(6,1) =  1 : PTS(6,2) =  1
+5070 PTS(7,0) = -1: PTS(7,1) =  1 : PTS(7,2) =  1
+5080 RETURN
+
+6000 REM DRAW LINES
+6010 A = 0 : B = 1 : GOSUB 500
+6020 A = 1 : B = 2 : GOSUB 500
+6030 A = 2 : B = 3 : GOSUB 500
+6040 A = 3 : B = 0 : GOSUB 500
+6050 A = 4 : B = 5 : GOSUB 500
+6060 A = 5 : B = 6 : GOSUB 500
+6070 A = 6 : B = 7 : GOSUB 500
+6080 A = 7 : B = 4 : GOSUB 500
+6090 A = 0 : B = 4 : GOSUB 500
+6100 A = 1 : B = 5 : GOSUB 500
+6110 A = 2 : B = 6 : GOSUB 500
+6120 A = 3 : B = 7 : GOSUB 500
+6130 RETURN

package/examples/hello.s

@@ -0,0 +1,55 @@
+**********************************
+*                                *
+*     HELLO WORLD - APPLE IIE    *
+*     65C02 ASSEMBLY EXAMPLE     *
+*                                *
+**********************************
+
+* Apple IIe ROM routines
+COUT     EQU  $FDED       ;Character output routine
+
+         ORG  $0800       ;Standard BASIC program area
+
+**********************************
+* Main program entry point
+**********************************
+START    LDX  #$00        ;Initialize index to 0
+
+**********************************
+* Print loop - one char at a time
+**********************************
+LOOP     LDA  MESSAGE,X   ;Load character at MESSAGE+X
+         BEQ  DONE        ;If zero (end of string), we're done
+         JSR  COUT        ;Print the character
+         PHX              ;Save X on stack (65C02)
+         JSR  DELAY       ;Wait a bit
+         PLX              ;Restore X from stack (65C02)
+         INX              ;Increment index
+         BNE  LOOP        ;Continue if X hasn't wrapped
+
+**********************************
+* End of program
+**********************************
+DONE     RTS              ;Return to caller
+
+**********************************
+* Delay routine - nested loop
+* Adjust WAIT value for longer/shorter delay
+**********************************
+WAIT     EQU  $60         ;Delay multiplier (~100ms)
+
+DELAY    LDY  #WAIT       ;Outer loop counter
+DLY1     LDX  #$FF        ;Inner loop counter
+DLY2     DEX              ;Decrement inner
+         BNE  DLY2        ;Loop until X=0
+         DEY              ;Decrement outer
+         BNE  DLY1        ;Loop until Y=0
+         RTS
+
+**********************************
+* Message data
+* Using " delimiter sets high bit automatically
+**********************************
+MESSAGE  ASC  "HELLO APPLE IIE!"
+         DFB  $8D         ;Carriage return (with high bit)
+         DFB  $00         ;Null terminator

package/examples/scroll.s

@@ -0,0 +1,140 @@
+; scroll.s - Smooth horizontal text scroller for Apple IIe
+;
+; Scrolls a message across the top line of the 40-column text screen.
+; The message slides in from the right, crosses the screen, and exits left
+; before looping. Press any key to quit.
+;
+; Assemble with Merlin or ca65:
+;   ca65 scroll.s -o scroll.o && ld65 scroll.o -t none -o SCROLL -S 0x0300
+;
+; Run from the monitor:  300G
+; Or BRUN from DOS/ProDOS after saving.
+
+            ORG  $0300
+
+; ── Zero page temporaries ──────────────────────────────────────────────
+
+OFFSET      EQU  $06            ; current scroll offset (2 bytes)
+SRCPTR      EQU  $08            ; pointer into message buffer (2 bytes)
+
+; ── Hardware / ROM addresses ───────────────────────────────────────────
+
+TXTLINE0    EQU  $0400          ; screen RAM for text line 0
+KBDSTROBE   EQU  $C000          ; keyboard data (bit 7 = key ready)
+KBDCLEAR    EQU  $C010          ; clear keyboard strobe
+HOME        EQU  $FC58          ; ROM: clear screen and home cursor
+
+; ── Constants ──────────────────────────────────────────────────────────
+
+SCRWIDTH    EQU  40             ; visible columns
+SPEED       EQU  $18            ; delay — lower = faster
+
+; ======================================================================
+; Entry — jump over data block so BUFLEN is defined before use
+; ======================================================================
+
+            JMP  START
+
+; ======================================================================
+; Message buffer
+;
+; Padded with 40 spaces on each side so the text scrolls cleanly on and
+; off screen.  Characters have the high bit set for normal Apple II text
+; (ASCII + $80).
+; ======================================================================
+
+BUFFER
+; 40 leading spaces
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 10
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 20
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 30
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 40
+
+; Message: "HELLO FROM THE APPLE //E EMULATOR! "
+            HEX  C8C5CCCCCF             ; HELLO
+            HEX  A0                     ; (space)
+            HEX  C6D2CFCD              ; FROM
+            HEX  A0                     ; (space)
+            HEX  D4C8C5                 ; THE
+            HEX  A0                     ; (space)
+            HEX  C1D0D0CCC5            ; APPLE
+            HEX  A0AFAFC5              ; (space)//E
+            HEX  A0                     ; (space)
+            HEX  C5CDD5CCC1D4CFD2      ; EMULATOR
+            HEX  A1                     ; !
+            HEX  A0A0A0                 ; (trailing spaces before pad)
+
+MSGLEN      EQU  *-BUFFER-40    ; length of message + trailing spaces
+
+; 40 trailing spaces
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 10
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 20
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 30
+            HEX  A0A0A0A0A0A0A0A0A0A0  ; 40
+
+BUFEND
+BUFLEN      EQU  BUFEND-BUFFER-SCRWIDTH+1  ; number of scroll positions
+
+; ======================================================================
+; Main code
+; ======================================================================
+
+START       JSR  HOME           ; clear screen
+
+            LDA  #0             ; reset scroll offset
+            STA  OFFSET
+            STA  OFFSET+1
+
+; ── Main loop ─────────────────────────────────────────────────────────
+
+LOOP        LDA  OFFSET         ; SRCPTR = BUFFER + OFFSET
+            CLC
+            ADC  #<BUFFER
+            STA  SRCPTR
+            LDA  OFFSET+1
+            ADC  #>BUFFER
+            STA  SRCPTR+1
+
+; Copy 40 characters from SRCPTR to screen line 0
+
+            LDY  #SCRWIDTH-1
+COPY        LDA  (SRCPTR),Y
+            STA  TXTLINE0,Y
+            DEY
+            BPL  COPY
+
+; Advance the offset; wrap when we reach the end of the padded message
+
+            INC  OFFSET
+            BNE  NOWRAP
+            INC  OFFSET+1
+NOWRAP
+            LDA  OFFSET+1       ; compare OFFSET with BUFLEN
+            CMP  #>BUFLEN
+            BCC  NODELAY        ; high byte less — not at end
+            BNE  DORESET        ; high byte greater — past end
+            LDA  OFFSET
+            CMP  #<BUFLEN
+            BCC  NODELAY        ; low byte < BUFLEN — continue
+DORESET     LDA  #0             ; wrap offset back to zero
+            STA  OFFSET
+            STA  OFFSET+1
+            JMP  LOOP
+NODELAY
+
+; ── Frame delay ───────────────────────────────────────────────────────
+
+            LDX  #SPEED
+DELAYOUTER  LDY  #0
+DELAYINNER  DEY
+            BNE  DELAYINNER
+            DEX
+            BNE  DELAYOUTER
+
+; ── Check for keypress (quit on any key) ──────────────────────────────
+
+            LDA  KBDSTROBE
+            BPL  LOOP           ; no key — keep scrolling
+            STA  KBDCLEAR       ; clear strobe
+            RTS                 ; return to caller / monitor
+

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "web-a2e",
+  "version": "1.0.0",
+  "description": "Apple //e emulator for the browser",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "npm run build:wasm && vite build",
+    "build:wasm": "mkdir -p build && cd build && emcmake cmake .. && emmake make -j$(nproc 2>/dev/null || sysctl -n hw.ncpu)",
+    "preview": "vite preview",
+    "clean": "rm -rf build dist public/a2e.js public/a2e.wasm",
+    "deploy": "rsync -avz --delete dist/ vps-mike:web-a2e/data/",
+    "deploy:staging": "rsync -avz --delete dist/ vps-mike:/home/mike/web-a2e-staging/data/"
+  },
+  "devDependencies": {
+    "vite": "^7.3.1"
+  }
+}