Deploy KLH10 TOPS-20 emulator

.dockerignore

@@ -0,0 +1,7 @@
+.git/
+.claude/
+Panda-doc/
+node_modules/
+*.tap
+build/wasm/bld-*/RH20.*
+build/wasm/bld-*/*-dbd9

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sav filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,22 @@
+# Hugging Face Spaces Dockerfile for KLH10 TOPS-20 WebAssembly Emulator
+#
+# Deploy to HF Spaces using deploy-huggingface.sh, or manually:
+#   1. Create a Docker Space on huggingface.co
+#   2. Copy this file as "Dockerfile" into the Space repo
+#   3. Push to HF
+
+FROM node:22-slim
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl bzip2 ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+WORKDIR /app
+COPY . .
+RUN ./download-images.sh && chown -R user:user /app
+
+USER user
+ENV PORT=7860
+EXPOSE 7860
+CMD ["node", "build/wasm/bld-kl/serve.js"]

README.md

@@ -1,12 +1,24 @@
 ---
-title: Tops20
-emoji: 🌖
-colorFrom: pink
-colorTo: yellow
+title: TOPS-20 PDP-10 Emulator
+emoji: "\U0001F5A5"
+colorFrom: blue
+colorTo: blue
 sdk: docker
-pinned: false
-license: other
-short_description: Standalone in-browser PDP 10 Emulator  running TOPS-20
+app_port: 7860
+custom_headers:
+  cross-origin-embedder-policy: require-corp
+  cross-origin-opener-policy: same-origin
+  cross-origin-resource-policy: cross-origin
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# TOPS-20 PDP-10 Emulator
+
+A PDP-10 mainframe emulator running DEC TOPS-20 V7.0 in your browser via WebAssembly.
+
+Click **Boot TOPS-20** and wait ~30 seconds for the boot sequence to complete.
+
+WebAssembly port via agentic coding by Rob Chang.
+KLH10 emulator by Kenneth L. Harrenstien.
+Panda TOPS-20 distribution by Mark Crispin.
+
+Source: [github.com/robchang/tops20](https://github.com/robchang/tops20)

build/wasm/bld-kl/boot.sav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2e0c3d1ea76b81fa1c5aaa8b3922acacc7e87f168befa35f4867939389f764f
+size 23280

build/wasm/bld-kl/emulator-worker.js

@@ -0,0 +1,376 @@
+// Web Worker for KLH10 PDP-10 Emulator
+console.log('Worker script loaded successfully');
+
+// Ring Buffer Manager for shared memory communication
+class RingBufferManager {
+    constructor(sharedBuffer, baseOffset = 0) {
+        this.buffer = new Uint8Array(sharedBuffer);
+        this.view = new DataView(sharedBuffer);
+        
+        // Buffer layout:
+        // Input ring buffer: offset 0, size 4112 (4096 data + 16 metadata)
+        // Output ring buffer: offset 4112, size 4112 (4096 data + 16 metadata)  
+        // Control: offset 8224, size 16 (mode + flush_request + padding)
+        
+        this.baseOffset = baseOffset;
+        this.inputOffset = baseOffset;
+        this.outputOffset = baseOffset + 4112;
+        this.controlOffset = baseOffset + 8224;
+    }
+    
+    // Input ring buffer (JavaScript writes, WASM reads)
+    writeInputChar(char) {
+        const writePos = this.view.getUint32(this.inputOffset, true);
+        const readPos = this.view.getUint32(this.inputOffset + 4, true);
+        const size = 4096;
+        
+        const nextWritePos = (writePos + 1) % size;
+        if (nextWritePos === readPos) {
+            return false; // Buffer full
+        }
+        
+        this.buffer[this.inputOffset + 16 + writePos] = char.charCodeAt(0);
+        this.view.setUint32(this.inputOffset, nextWritePos, true);
+        return true;
+    }
+    
+    writeInputLine(line) {
+        // Write each character followed by newline
+        for (let i = 0; i < line.length; i++) {
+            if (!this.writeInputChar(line[i])) {
+                return false; // Buffer full
+            }
+        }
+        // Add newline to complete the line
+        return this.writeInputChar('\n');
+    }
+    
+    // Output ring buffer (WASM writes, JavaScript reads)
+    readOutputChar() {
+        const writePos = this.view.getUint32(this.outputOffset, true);
+        const readPos = this.view.getUint32(this.outputOffset + 4, true);
+        
+        if (readPos === writePos) {
+            return null; // Buffer empty
+        }
+        
+        const char = this.buffer[this.outputOffset + 16 + readPos];
+        const nextReadPos = (readPos + 1) % 4096;
+        this.view.setUint32(this.outputOffset + 4, nextReadPos, true);
+        
+        return String.fromCharCode(char);
+    }
+    
+    hasOutputData() {
+        const writePos = this.view.getUint32(this.outputOffset, true);
+        const readPos = this.view.getUint32(this.outputOffset + 4, true);
+        return readPos !== writePos;
+    }
+    
+    // Output ring buffer (WASM writes, JavaScript reads) - Worker side writing
+    writeOutputChar(char) {
+        const writePos = this.view.getUint32(this.outputOffset, true);
+        const readPos = this.view.getUint32(this.outputOffset + 4, true);
+        const size = 4096;
+        
+        const nextWritePos = (writePos + 1) % size;
+        if (nextWritePos === readPos) {
+            return false; // Buffer full
+        }
+        
+        this.buffer[this.outputOffset + 16 + writePos] = char.charCodeAt(0);
+        this.view.setUint32(this.outputOffset, nextWritePos, true);
+        return true;
+    }
+    
+    // Control functions
+    getCurrentMode() {
+        return this.view.getUint32(this.controlOffset, true);
+    }
+    
+    getFlushRequest() {
+        return this.view.getUint32(this.controlOffset + 4, true);
+    }
+    
+    clearFlushRequest() {
+        this.view.setUint32(this.controlOffset + 4, 0, true);
+    }
+}
+
+class EmulatorWorker {
+    constructor() {
+        this.Module = null;
+        this.isRunning = false;
+        
+        // Shared WebAssembly memory - set from main thread
+        this.wasmMemory = null;
+        this.ringBufferBase = null;
+    }
+
+    async initialize() {
+        return new Promise((resolve, reject) => {
+            console.log('Worker: Starting initialization...');
+            try {
+                // Configure Module to use shared WebAssembly memory
+                console.log('Worker: Configuring Module with shared memory:', this.wasmMemory);
+                console.log('Worker: Shared memory buffer size:', this.wasmMemory.buffer.byteLength);
+                
+                self.Module = {
+                    // Use the shared memory passed from main thread
+                    wasmMemory: this.wasmMemory,
+                    // Capture stdout/stderr and write directly to shared ring buffer
+                    print: (text) => {
+                        // Clean up any invalid UTF-8 characters
+                        const cleanText = text.replace(/[\u00A9]/g, '(C)').replace(/\uFFFD/g, '');
+                        
+                        // Check if this is a prompt (KLH10# or KLH10> or KLH10>>)
+                        const isPrompt = /^KLH10[#>]+\s*$/.test(cleanText.trim());
+                        
+                        if (isPrompt) {
+                            // Prompts should not have newlines added
+                            this.writeToWasmOutputRing(cleanText);
+                        } else {
+                            // Regular output needs newlines added
+                            this.writeToWasmOutputRing(cleanText + '\n');
+                        }
+                    },
+                    printErr: (text) => {
+                        // Clean up any invalid UTF-8 characters  
+                        const cleanText = text.replace(/[\u00A9]/g, '(C)').replace(/\uFFFD/g, '');
+                        // Add newline since Module.print() is line-based and Emscripten strips \n
+                        this.writeToWasmOutputRing(cleanText + '\n');
+                    },
+                    
+                    // Handle module ready
+                    onRuntimeInitialized: async () => {
+                        this.Module = self.Module;
+                        
+                        // Set up ring buffers in WASM memory IMMEDIATELY before anything else
+                        this.setupWasmRingBuffers();
+                        
+                        // Create empty config file in virtual file system
+                        // KLH10 processes each line as a command, so we want an empty file
+                        const configContent = ``;
+                        
+                        try {
+                            // Create config file with same name as program (KLH10 default behavior)
+                            this.Module.FS.writeFile('/kn10-kl', configContent);
+                            
+                            // Preload all available .tap files
+                            const potentialTapes = [
+                            ];
+                            
+                            for (const tapeFile of potentialTapes) {
+                                try {
+                                    console.log('Worker: Attempting to preload tape:', tapeFile);
+                                    
+                                    // Fetch the tape file
+                                    const response = await fetch('/' + tapeFile);
+                                    if (response.ok) {
+                                        const arrayBuffer = await response.arrayBuffer();
+                                        const uint8Array = new Uint8Array(arrayBuffer);
+                                        
+                                        // Write to the virtual filesystem
+                                        this.Module.FS.writeFile(tapeFile, uint8Array);
+                                        console.log('Worker: Tape loaded successfully:', tapeFile, uint8Array.length, 'bytes');
+                                    } else {
+                                        console.log('Worker: Tape file not found (skipping):', tapeFile);
+                                    }
+                                } catch (e) {
+                                    console.log('Worker: Tape file not available (skipping):', tapeFile);
+                                }
+                            }
+                            
+                            // Preload bootstrap files if they exist (KL10 variants)
+                            const bootFiles = ['boot.sav', 'mtboot.sav'];
+                            for (const bootFile of bootFiles) {
+                                try {
+                                    const response = await fetch('/' + bootFile);
+                                    if (response.ok) {
+                                        const arrayBuffer = await response.arrayBuffer();
+                                        const uint8Array = new Uint8Array(arrayBuffer);
+                                        this.Module.FS.writeFile(bootFile, uint8Array);
+                                        console.log('Bootstrap file loaded:', bootFile, uint8Array.length, 'bytes');
+                                    }
+                                } catch (e) {
+                                    // Ignore if bootstrap files don't exist
+                                }
+                            }
+                            
+                            // Preload Panda disk image
+                            try {
+                                console.log('Worker: Loading Panda disk image: RH20.RP07.1');
+                                const response = await fetch('/RH20.RP07.1');
+                                if (response.ok) {
+                                    const arrayBuffer = await response.arrayBuffer();
+                                    const uint8Array = new Uint8Array(arrayBuffer);
+                                    this.Module.FS.writeFile('RH20.RP07.1', uint8Array);
+                                    console.log('Worker: Panda disk image loaded:', uint8Array.length, 'bytes');
+                                } else {
+                                    console.error('Worker: Could not load Panda disk image RH20.RP07.1');
+                                }
+                            } catch (e) {
+                                console.error('Worker: Error loading Panda disk image:', e);
+                            }
+                            
+                            // List all files in the virtual filesystem for debugging
+                            try {
+                                var files = this.Module.FS.readdir('/');
+                                console.log('Files in virtual filesystem:', files);
+                            } catch (e) {
+                                console.warn('Could not list files:', e);
+                            }
+                        } catch (err) {
+                            console.warn('Could not create config file:', err);
+                        }
+                        
+                        this.sendMessage('ready');
+                        resolve();
+                    },
+                    
+                    // Handle exit
+                    onExit: (code) => {
+                        this.isRunning = false;
+                        this.sendMessage('exit', code);
+                    },
+                    
+                    // Don't quit on main exit
+                    quit: (status, toThrow) => {
+                        this.isRunning = false;
+                        this.sendMessage('exit', status);
+                    },
+                    
+                    // Disable automatic main execution
+                    noInitialRun: true,
+                    
+                    // Capture errors
+                    onAbort: (reason) => {
+                        this.sendMessage('error', `Emulator aborted: ${reason}`);
+                        reject(new Error(`Emulator aborted: ${reason}`));
+                    }
+                };
+
+                // Import the Emscripten-generated JavaScript (use new filename to bypass cache)
+                console.log('Worker: About to import kn10-kl.js...');
+                importScripts('kn10-kl.js');
+                console.log('Worker: Successfully imported kn10-kl.js');
+                
+            } catch (error) {
+                console.error('Failed to load Emscripten script:', error);
+                console.error('Error stack:', error.stack);
+                this.sendMessage('error', `Failed to load emulator: ${error.message} | Stack: ${error.stack}`);
+                reject(error);
+            }
+        });
+    }
+
+    startEmulator() {
+        try {
+            if (!this.Module || !this.Module.callMain) {
+                throw new Error('Module not properly initialized');
+            }
+
+            this.isRunning = true;
+            
+            
+            // Run the main function with config file argument
+            // argv[0] = program name, argv[1] = config file
+            setTimeout(() => {
+                try {
+                    // Run without config file argument - will use default "kn10-kl" file
+                    this.Module.callMain(['kn10-kl']);
+                } catch (e) {
+                    console.error('callMain error:', e);
+                    this.sendMessage('error', `Main execution failed: ${e.message}`);
+                }
+            }, 100);
+            
+        } catch (error) {
+            this.sendMessage('error', `Failed to start emulator: ${error.message}`);
+        }
+    }
+
+    setupWasmRingBuffers() {
+        if (!this.wasmMemory || !this.ringBufferBase) {
+            console.error('❌ No shared WASM memory or ring buffer base provided');
+            return;
+        }
+        
+        console.log('Worker: Setting up ring buffers in shared WASM memory');
+        console.log('Worker: WASM memory buffer:', this.wasmMemory.buffer.byteLength, 'bytes');
+        console.log('Worker: Ring buffer base offset:', this.ringBufferBase.toString(16));
+        
+        if (this.Module && this.Module._klh10_set_ring_buffer_offset) {
+            // Tell WASM where the ring buffers are located in its own memory
+            this.Module._klh10_set_ring_buffer_offset(this.ringBufferBase);
+            
+            // Create output ring buffer manager for JavaScript to write to
+            // RingBufferManager calculates output offset internally from base
+            this.outputRingBuffer = new RingBufferManager(this.wasmMemory.buffer, this.ringBufferBase);
+            
+            console.log('Worker: Ring buffers initialized at WASM memory offset:', this.ringBufferBase.toString(16));
+        } else {
+            console.error('Worker: klh10_set_ring_buffer_offset function not found');
+        }
+    }
+
+    writeToWasmOutputRing(text) {
+        if (!this.outputRingBuffer) {
+            console.warn('Worker: Cannot write to output ring - not initialized');
+            return;
+        }
+        
+        // Write each character directly to WASM memory output ring buffer
+        for (let i = 0; i < text.length; i++) {
+            const success = this.outputRingBuffer.writeOutputChar(text[i]);
+            if (!success) {
+                console.warn('Worker: Output ring buffer full, character dropped');
+                break;
+            }
+        }
+    }
+    
+    
+
+    sendMessage(type, data = null) {
+        self.postMessage({ type, data });
+    }
+}
+
+// Create worker instance
+console.log('Creating EmulatorWorker instance...');
+const worker = new EmulatorWorker();
+console.log('EmulatorWorker instance created');
+
+// Handle messages from main thread
+self.onmessage = async (event) => {
+    const { type, wasmMemory, ringBufferBase } = event.data;
+    
+    switch (type) {
+        case 'start':
+            console.log('Worker: Starting emulator with shared WASM memory...');
+            if (wasmMemory) {
+                worker.wasmMemory = wasmMemory;
+                worker.ringBufferBase = ringBufferBase;
+                console.log('Worker: Received shared WASM memory:', wasmMemory.buffer.byteLength, 'bytes');
+                console.log('Worker: Ring buffer base:', ringBufferBase.toString(16));
+            } else {
+                console.error('Worker: No shared WASM memory provided!');
+            }
+            try {
+                await worker.initialize();
+                // After successful initialization, start the emulator
+                worker.startEmulator();
+            } catch (error) {
+                worker.sendMessage('error', `Initialization failed: ${error.message}`);
+            }
+            break;
+            
+        case 'mode_change':
+            worker.sendMessage('mode_change', data);
+            break;
+            
+        default:
+            worker.sendMessage('error', `Unknown message type: ${type}`);
+    }
+};

build/wasm/bld-kl/index.html

@@ -0,0 +1,130 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>KLH10 PDP-10 Emulator - WebAssembly</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/xterm@5.3.0/css/xterm.css" />
+    <style>
+        body {
+            margin: 0;
+            padding: 20px;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background-color: #1e1e1e;
+            color: #ffffff;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        h1 {
+            text-align: center;
+            color: #4fc3f7;
+            margin-bottom: 30px;
+        }
+        .terminal-container {
+            background-color: #000;
+            border: 2px solid #333;
+            border-radius: 8px;
+            padding: 10px;
+            margin-bottom: 20px;
+        }
+        .controls {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        button {
+            background-color: #4fc3f7;
+            color: #000;
+            border: none;
+            padding: 10px 15px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 14px;
+            margin: 5px;
+            min-width: 120px;
+        }
+        button:hover {
+            background-color: #29b6f6;
+        }
+        button:disabled {
+            background-color: #666;
+            cursor: not-allowed;
+        }
+        .boot-btn {
+            font-size: 18px;
+            padding: 14px 32px;
+            min-width: 200px;
+            background-color: #4fc3f7;
+        }
+        .boot-btn:hover {
+            background-color: #29b6f6;
+        }
+        .mode-toggle {
+            margin-top: 8px;
+            font-size: 12px;
+        }
+        .mode-toggle a {
+            color: #888;
+            text-decoration: none;
+        }
+        .mode-toggle a:hover {
+            color: #4fc3f7;
+            text-decoration: underline;
+        }
+        .status {
+            text-align: center;
+            margin: 10px 0;
+            font-size: 14px;
+        }
+        .status.loading {
+            color: #ffb74d;
+        }
+        .status.ready {
+            color: #81c784;
+        }
+        .status.error {
+            color: #e57373;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>KLH10 PDP-10 Emulator</h1>
+        
+        <div class="status" id="status">Initializing...</div>
+        
+        <div class="controls" id="simpleControls">
+            <button id="autoBootBtn" class="boot-btn">Boot TOPS-20</button>
+            <div class="mode-toggle">
+                <a href="#" id="showAdvanced">Advanced Mode</a>
+            </div>
+        </div>
+
+        <div class="controls" id="advancedControls" style="display: none;">
+            <button id="startBtn" disabled>Start Emulator</button>
+            <button id="resetBtn" disabled>Reset</button>
+            <button id="loadConfigBtn" disabled>Load TOPS-20 Config</button>
+            <button id="bootTops20Btn" disabled>BOOT TOPS-20</button>
+            <div class="mode-toggle">
+                <a href="#" id="showSimple">Simple Mode</a>
+            </div>
+        </div>
+        
+        <div class="terminal-container">
+            <div id="terminal"></div>
+        </div>
+        
+        <div style="text-align: center; font-size: 12px; color: #888; margin-top: 20px;">
+            WebAssembly port via agentic coding by Rob Chang<br>
+            KLH10 PDP-10 Emulator by Kenneth L. Harrenstien<br>
+            Panda TOPS-20 distribution by Mark Crispin<br>
+            <span style="color: #666;">Networking is disabled in this build</span>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/xterm@5.3.0/lib/xterm.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/xterm-addon-fit@0.8.0/lib/xterm-addon-fit.js"></script>
+    <script src="main.js"></script>
+</body>
+</html>

build/wasm/bld-kl/kn10-kl.wasm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65b7d723f5cb03cecf2303ee732493c9bb45142562fb686d101aa8d2a589509d
+size 399870

build/wasm/bld-kl/main.js

@@ -0,0 +1,785 @@
+// Main web interface for KLH10 PDP-10 Emulator
+
+// Ring Buffer Manager for shared memory communication (shared with worker)
+class RingBufferManager {
+    constructor(sharedBuffer, baseOffset = 0) {
+        this.buffer = new Uint8Array(sharedBuffer);
+        this.view = new DataView(sharedBuffer);
+        
+        // Buffer layout:
+        // Input ring buffer: offset 0, size 4112 (4096 data + 16 metadata)
+        // Output ring buffer: offset 4112, size 4112 (4096 data + 16 metadata)  
+        // Control: offset 8224, size 16 (mode + flush_request + padding)
+        
+        this.baseOffset = baseOffset;
+        this.inputOffset = baseOffset;
+        this.outputOffset = baseOffset + 4112;
+        this.controlOffset = baseOffset + 8224;
+    }
+    
+    // Input ring buffer (JavaScript writes, WASM reads)
+    writeInputChar(char) {
+        const writePos = this.view.getUint32(this.inputOffset, true);
+        const readPos = this.view.getUint32(this.inputOffset + 4, true);
+        const size = 4096;
+        
+        const nextWritePos = (writePos + 1) % size;
+        if (nextWritePos === readPos) {
+            return false; // Buffer full
+        }
+        
+        this.buffer[this.inputOffset + 16 + writePos] = char.charCodeAt(0);
+        this.view.setUint32(this.inputOffset, nextWritePos, true);
+        return true;
+    }
+    
+    // Output ring buffer (WASM writes, JavaScript reads)
+    readOutputChar() {
+        const writePos = this.view.getUint32(this.outputOffset, true);
+        const readPos = this.view.getUint32(this.outputOffset + 4, true);
+        
+        if (readPos === writePos) {
+            return null; // Buffer empty
+        }
+        
+        const char = this.buffer[this.outputOffset + 16 + readPos];
+        const nextReadPos = (readPos + 1) % 4096;
+        this.view.setUint32(this.outputOffset + 4, nextReadPos, true);
+        
+        return String.fromCharCode(char);
+    }
+    
+    hasOutputData() {
+        const writePos = this.view.getUint32(this.outputOffset, true);
+        const readPos = this.view.getUint32(this.outputOffset + 4, true);
+        return readPos !== writePos;
+    }
+}
+
+class KLH10WebInterface {
+    constructor() {
+        this.terminal = null;
+        this.fitAddon = null;
+        this.worker = null;
+        this.emulatorReady = false;
+        this.inRuncmdMode = true;   // KLH10 starts in command mode by default
+        this.terminalEchoEnabled = true;  // Terminal echo enabled by default
+        this.autoBootInProgress = false;  // True during one-click boot sequence
+        this._readyResolve = null;        // Promise resolve for waitForReady()
+        
+        // Shared WebAssembly memory (proper approach)
+        this.wasmMemory = null;
+        this.inputRingBuffer = null;
+        this.outputRingBuffer = null;
+        
+        this.initializeTerminal();
+        this.setupEventListeners();
+        this.updateStatus('Ready to start emulator', 'ready');
+    }
+
+    initializeTerminal() {
+        // Create xterm.js terminal
+        this.terminal = new Terminal({
+            theme: {
+                background: '#000000',
+                foreground: '#ffffff',
+                cursor: '#ffffff',
+                cursorAccent: '#000000',
+                selection: '#44475a',
+            },
+            fontFamily: 'Consolas, "Courier New", monospace',
+            fontSize: 14,
+            cursorBlink: true,
+            cols: 80,
+            rows: 24,
+            convertEol: true,  // Convert \n to \r\n for proper line breaks
+            windowsMode: false // Keep Unix-style line endings in input
+        });
+
+        // Add fit addon for responsive terminal
+        this.fitAddon = new FitAddon.FitAddon();
+        this.terminal.loadAddon(this.fitAddon);
+
+        // Open terminal in DOM
+        this.terminal.open(document.getElementById('terminal'));
+        this.fitAddon.fit();
+        this.terminal.resize(this.terminal.cols, 24);
+
+        // Handle terminal input
+        this.terminal.onData((data) => {
+            if (this.autoBootInProgress) return; // Block input during auto-boot
+            if (this.worker && this.emulatorReady && this.inputRingBuffer) {
+                // Echo input based on both mode and echo setting
+                if (this.inRuncmdMode && this.terminalEchoEnabled) {
+                    // Handle special characters
+                    if (data === '\r' || data === '\n') {
+                        this.terminal.write('\r\n');
+                    } else if (data === '\b' || data === '\x7f') {
+                        // Backspace handling
+                        this.terminal.write('\b \b');
+                    } else if (data >= ' ' && data <= '~') {
+                        // Printable characters
+                        this.terminal.write(data);
+                    }
+                }
+                
+                // Write directly to WASM memory ring buffer - true zero-copy!
+                
+                
+                for (let i = 0; i < data.length; i++) {
+                    const char = data[i];
+                    const success = this.inputRingBuffer.writeInputChar(char);
+                    
+                    
+                    if (!success) {
+                        console.warn('Main: Input ring buffer full, character dropped');
+                        break;
+                    }
+                }
+            }
+        });
+
+        // Handle window resize (fit width, keep 24 rows)
+        window.addEventListener('resize', () => {
+            this.fitAddon.fit();
+            this.terminal.resize(this.terminal.cols, 24);
+        });
+
+        // Initial welcome message
+        this.terminal.writeln('\x1b[36mKLH10 PDP-10 Emulator - WebAssembly Port\x1b[0m');
+        this.terminal.writeln('Click "Boot TOPS-20" to begin...');
+        this.terminal.writeln('');
+        
+        // Focus the terminal for immediate keyboard input
+        this.terminal.focus();
+    }
+
+    setupEventListeners() {
+        // Simple mode
+        document.getElementById('autoBootBtn').addEventListener('click', () => this.autoBoot());
+        document.getElementById('showAdvanced').addEventListener('click', (e) => {
+            e.preventDefault();
+            document.getElementById('simpleControls').style.display = 'none';
+            document.getElementById('advancedControls').style.display = '';
+        });
+        document.getElementById('showSimple').addEventListener('click', (e) => {
+            e.preventDefault();
+            document.getElementById('advancedControls').style.display = 'none';
+            document.getElementById('simpleControls').style.display = '';
+        });
+
+        // Advanced mode
+        const startBtn = document.getElementById('startBtn');
+        const resetBtn = document.getElementById('resetBtn');
+        const loadConfigBtn = document.getElementById('loadConfigBtn');
+        const bootTops20Btn = document.getElementById('bootTops20Btn');
+
+        startBtn.addEventListener('click', () => this.startEmulator());
+        resetBtn.addEventListener('click', () => this.resetEmulator());
+        loadConfigBtn.addEventListener('click', () => this.loadInstallationConfig());
+        bootTops20Btn.addEventListener('click', () => this.bootTops20());
+
+        // Enable start button
+        startBtn.disabled = false;
+    }
+
+    updateStatus(message, type = '') {
+        const statusEl = document.getElementById('status');
+        statusEl.textContent = message;
+        statusEl.className = `status ${type}`;
+    }
+
+    async startEmulator() {
+        try {
+            this.updateStatus('Loading emulator...', 'loading');
+            document.getElementById('startBtn').disabled = true;
+            
+            this.terminal.writeln('Starting KLH10 emulator...');
+            this.terminal.writeln('');
+
+            // Create shared WebAssembly memory (proper architecture)
+            this.wasmMemory = new WebAssembly.Memory({
+                initial: 256,    // 16MB initial 
+                maximum: 512,    // 32MB maximum
+                shared: true     // CRITICAL: Shared between main thread and worker
+            });
+            
+            // Ring buffers will be at known offsets in WASM memory
+            const RING_BUFFER_BASE = 0x10000;  // 64KB offset
+            
+            // Ring buffers will be at known offsets in WASM memory  
+            // Create ONE ring buffer manager with the base offset
+            // It will handle both input (at base) and output (at base + 4112) internally
+            this.ringBufferManager = new RingBufferManager(this.wasmMemory.buffer, RING_BUFFER_BASE);
+            
+            // For compatibility, create aliases that point to the same manager
+            this.inputRingBuffer = this.ringBufferManager;
+            this.outputRingBuffer = this.ringBufferManager;
+            
+            // console.log('Main: Created shared WASM memory:', this.wasmMemory.buffer.byteLength, 'bytes');
+            // console.log('Main: Input ring at offset:', this.ringBufferManager.inputOffset.toString(16));
+            // console.log('Main: Output ring at offset:', this.ringBufferManager.outputOffset.toString(16));
+
+            // Create Web Worker for emulator with cache-busting
+            const timestamp = Date.now();
+            this.worker = new Worker(`emulator-worker.js?v=${timestamp}`);
+            
+            // Handle messages from worker
+            this.worker.onmessage = (event) => {
+                const { type, data } = event.data;
+                
+                switch (type) {
+                    case 'ready':
+                        this.emulatorReady = true;
+                        this.updateStatus('Emulator ready', 'ready');
+                        document.getElementById('resetBtn').disabled = false;
+                        document.getElementById('loadConfigBtn').disabled = false;
+                        document.getElementById('bootTops20Btn').disabled = true; // Only enable after config loaded
+
+                        // Start polling output from shared ring buffer
+                        this.startOutputPolling();
+
+                        // Resolve waitForReady() promise if auto-booting
+                        if (this._readyResolve) {
+                            this._readyResolve();
+                            this._readyResolve = null;
+                        }
+
+                        // Focus terminal after emulator starts
+                        this.terminal.focus();
+                        break;
+                        
+                    case 'mode_change':
+                        this.inRuncmdMode = (data === 'command');
+                        // Echo is automatically disabled in RUN mode, enabled in CMDRUN mode
+                        break;
+                        
+                    case 'error':
+                        this.updateStatus(`Error: ${data}`, 'error');
+                        console.error('Emulator error:', data);
+                        break;
+                        
+                    case 'exit':
+                        this.updateStatus('Emulator exited', '');
+                        this.terminal.writeln(`\x1b[33mEmulator exited with code: ${data}\x1b[0m`);
+                        this.emulatorReady = false;
+                        document.getElementById('startBtn').disabled = false;
+                        document.getElementById('resetBtn').disabled = true;
+                        document.getElementById('loadConfigBtn').disabled = true;
+                        document.getElementById('bootTops20Btn').disabled = true;
+                        
+                        // Stop output polling
+                        if (this.outputPollInterval) {
+                            clearInterval(this.outputPollInterval);
+                            this.outputPollInterval = null;
+                        }
+                        break;
+                }
+            };
+
+            this.worker.onerror = (error) => {
+                console.error('Worker error event:', error);
+                console.error('Worker error message:', error.message);
+                console.error('Worker error filename:', error.filename);
+                console.error('Worker error lineno:', error.lineno);
+                console.error('Worker error colno:', error.colno);
+                console.error('Worker error object:', error.error);
+                
+                this.updateStatus('Worker error', 'error');
+                console.error('Worker error:', error.message || 'undefined');
+                if (error.filename) {
+                    console.error(`Worker error location: ${error.filename}:${error.lineno}:${error.colno}`);
+                }
+            };
+
+            // Start the emulator with shared WASM memory
+            this.worker.postMessage({ 
+                type: 'start', 
+                wasmMemory: this.wasmMemory,
+                ringBufferBase: 0x10000  // Tell worker where ring buffers are located
+            });
+
+        } catch (error) {
+            this.updateStatus(`Failed to start: ${error.message}`, 'error');
+            console.error('Failed to start emulator:', error.message);
+            document.getElementById('startBtn').disabled = false;
+        }
+    }
+
+    async loadInstallationConfig() {
+        if (!this.worker || !this.emulatorReady || !this.inputRingBuffer) {
+            console.warn('Load config attempted but emulator not ready');
+            return;
+        }
+
+        try {
+            // Load the config commands from the text file
+            const response = await fetch('tops20-config-commands.txt');
+            if (!response.ok) {
+                throw new Error('Could not load config commands file');
+            }
+            
+            const commandsText = await response.text();
+            const lines = commandsText.split('\n');
+            
+            // Process commands and filter out comments/empty lines
+            const configCommands = [];
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    configCommands.push(trimmed);
+                }
+            }
+
+            this.terminal.writeln('\x1b[36mLoading TOPS-20 Installation Configuration...\x1b[0m');
+            this.terminal.writeln('\x1b[33mCommands loaded from: tops20-config-commands.txt\x1b[0m');
+
+            // Send each command with a delay to simulate typing
+            let delay = 0;
+            configCommands.forEach((command, index) => {
+                setTimeout(() => {
+                    // Write command directly to WASM memory ring buffer
+                    const fullCommand = command + '\r';
+                    for (let i = 0; i < fullCommand.length; i++) {
+                        this.inputRingBuffer.writeInputChar(fullCommand[i]);
+                    }
+                    
+                    // Show what we're sending if in command mode
+                    if (this.inRuncmdMode) {
+                        this.terminal.write(command + '\r\n');
+                    }
+                    
+                    // After all commands, show completion message and update button states
+                    if (index === configCommands.length - 1) {
+                        setTimeout(() => {
+                            this.terminal.writeln('\x1b[32mConfiguration loaded! Ready to boot TOPS-20.\x1b[0m');
+                            
+                            // Disable Load Config button and enable BOOT TOPS-20 button
+                            document.getElementById('loadConfigBtn').disabled = true;
+                            document.getElementById('bootTops20Btn').disabled = false;
+                            
+                            // Focus terminal after config loads
+                            this.terminal.focus();
+                        }, 100);
+                    }
+                }, delay);
+                delay += 500; // 500ms delay between commands
+            });
+
+        } catch (error) {
+            this.terminal.writeln(`\x1b[31mError loading config commands: ${error.message}\x1b[0m`);
+            console.error('Error loading config commands:', error);
+        }
+    }
+
+    async bootTops20() {
+        if (!this.worker || !this.emulatorReady || !this.inputRingBuffer) {
+            console.warn('Boot TOPS-20 attempted but emulator not ready');
+            return;
+        }
+
+        try {
+            // Load the boot commands from the text file
+            const response = await fetch('tops20-boot-commands.txt');
+            if (!response.ok) {
+                throw new Error('Could not load boot commands file');
+            }
+            
+            const commandsText = await response.text();
+            const lines = commandsText.split('\n');
+            
+            // Process commands and filter out comments/empty lines
+            const bootCommands = [];
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('#')) {
+                    // Check if line starts with any { } command
+                    if (trimmed.startsWith('{')) {
+                        // Lines starting with { } commands - handle specially
+                        if (trimmed === '{date-time}') {
+                            // Generate current date/time in TOPS-20 format: DD-MMM-YYYY HHMM
+                            const now = new Date();
+                            const day = now.getDate().toString().padStart(2, '0');
+                            const months = ['JAN','FEB','MAR','APR','MAY','JUN',
+                                           'JUL','AUG','SEP','OCT','NOV','DEC'];
+                            const month = months[now.getMonth()];
+                            const year = now.getFullYear();
+                            const hours = now.getHours().toString().padStart(2, '0');
+                            const minutes = now.getMinutes().toString().padStart(2, '0');
+                            const dateTime = `${day}-${month}-${year} ${hours}${minutes}`;
+                            bootCommands.push({ command: dateTime, noCr: true }); // No CR for { } command lines
+                        } else if (trimmed === '{ctrl-c}') {
+                            // Send CTRL-C (ASCII 3)
+                            bootCommands.push({ command: '\x03', noCr: true }); // No CR for { } command lines
+                        } else if (trimmed.match(/^\{wait \d+\}$/)) {
+                            // Extract wait duration from {wait #} format
+                            const waitMatch = trimmed.match(/^\{wait (\d+)\}$/);
+                            const waitSeconds = parseInt(waitMatch[1], 10);
+                            bootCommands.push({ 
+                                command: null, 
+                                noCr: true, 
+                                waitSeconds: waitSeconds 
+                            });
+                        } else if (trimmed === '{echo on}') {
+                            // Turn on terminal echo
+                            bootCommands.push({ 
+                                command: null, 
+                                noCr: true, 
+                                echoControl: 'on' 
+                            });
+                        } else if (trimmed === '{echo off}') {
+                            // Turn off terminal echo
+                            bootCommands.push({ 
+                                command: null, 
+                                noCr: true, 
+                                echoControl: 'off' 
+                            });
+                        } else if (trimmed === '{cr}') {
+                            // Send carriage return
+                            bootCommands.push({ 
+                                command: '\r', 
+                                noCr: true  // Already includes CR, don't add another
+                            });
+                        }
+                        // Note: Lines starting with { } that we don't recognize are ignored
+                    } else {
+                        // Process {esc} and {nocr} inline within commands
+                        let processedCommand = trimmed;
+                        console.log(`[BOOT SCRIPT PARSE] Processing line: "${trimmed}"`);
+                        processedCommand = processedCommand.replace(/\{esc\}/g, '\x1b'); // ESC character (ASCII 27)
+                        
+                        // Handle {nocr} - mark command to not add \r
+                        const hasNoCr = processedCommand.includes('{nocr}');
+                        processedCommand = processedCommand.replace(/\{nocr\}/g, ''); // Remove {nocr} markers
+                        
+                        console.log(`[BOOT SCRIPT PARSE] Final processed command: "${processedCommand}", noCr: ${hasNoCr}`);
+                        
+                        // Store command with nocr flag
+                        bootCommands.push({
+                            command: processedCommand,
+                            noCr: hasNoCr
+                        });
+                    }
+                }
+            }
+
+            this.terminal.writeln('\x1b[36mStarting TOPS-20 boot sequence...\x1b[0m');
+            this.terminal.writeln('\x1b[33mCommands loaded from: tops20-boot-commands.txt\x1b[0m');
+            
+            // Disable the boot button immediately when starting
+            document.getElementById('bootTops20Btn').disabled = true;
+            
+            // Execute commands sequentially with non-blocking delays
+            this.executeCommandsSequentially(bootCommands, 0);
+        } catch (error) {
+            console.error('Error executing boot script:', error);
+            this.terminal.writeln('\x1b[31mError executing boot script: ' + error.message + '\x1b[0m');
+        }
+    }
+
+    executeCommandsSequentially(bootCommands, index, onComplete) {
+        if (index >= bootCommands.length) {
+            // All commands completed
+            if (!this.autoBootInProgress) {
+                this.terminal.writeln('\x1b[32mBOOT TOPS-20 sequence completed!\x1b[0m');
+                this.terminal.writeln('\x1b[33mContinue interacting with TOPS-20 system manually.\x1b[0m');
+            }
+            this.terminal.focus();
+            if (onComplete) onComplete();
+            return;
+        }
+
+        const commandEntry = bootCommands[index];
+        // Handle both string commands and object commands
+        let command, noCr, waitSeconds, echoControl;
+        if (typeof commandEntry === 'string') {
+            command = commandEntry;
+            noCr = false;
+            waitSeconds = 0;
+            echoControl = null;
+        } else {
+            command = commandEntry.command;
+            noCr = commandEntry.noCr;
+            waitSeconds = commandEntry.waitSeconds || 0;
+            echoControl = commandEntry.echoControl || null;
+        }
+
+        // Handle echo control commands
+        if (echoControl) {
+            if (echoControl === 'on') {
+                this.terminalEchoEnabled = true;
+                this.terminal.writeln('\x1b[32mTerminal echo enabled\x1b[0m');
+            } else if (echoControl === 'off') {
+                this.terminalEchoEnabled = false;
+                this.terminal.writeln('\x1b[33mTerminal echo disabled\x1b[0m');
+            }
+            // Continue with next command immediately
+            this.executeCommandsSequentially(bootCommands, index + 1, onComplete);
+            return;
+        }
+
+        // Handle wait commands
+        if (waitSeconds > 0) {
+            this.terminal.writeln(`\x1b[33mWaiting ${waitSeconds} seconds...\x1b[0m`);
+            // Wait and then continue with next command - this allows event loop to run
+            setTimeout(() => {
+                this.executeCommandsSequentially(bootCommands, index + 1, onComplete);
+            }, waitSeconds * 1000);
+            return;
+        }
+
+        // Skip null commands
+        if (command === null || command === undefined) {
+            this.executeCommandsSequentially(bootCommands, index + 1, onComplete);
+            return;
+        }
+
+        // Debug: Log what we're about to send
+        console.log(`[BOOT SCRIPT] Sending command: "${command}" (length: ${command.length}), noCr: ${noCr}`);
+        console.log(`[BOOT SCRIPT] Command char codes:`, Array.from(command).map(c => `${c}(${c.charCodeAt(0)})`).join(' '));
+
+        // Write command directly to WASM memory ring buffer
+        const fullCommand = noCr ? command : command + '\r';
+        console.log(`[BOOT SCRIPT] Full command: "${fullCommand}" (length: ${fullCommand.length})`);
+        for (let i = 0; i < fullCommand.length; i++) {
+            this.inputRingBuffer.writeInputChar(fullCommand[i]);
+        }
+
+        // Small delay before next command to allow processing
+        setTimeout(() => {
+            this.executeCommandsSequentially(bootCommands, index + 1, onComplete);
+        }, 500); // Small delay but allows event loop to run
+    }
+
+
+    startOutputPolling() {
+        // Poll output ring buffer at 60fps  
+        this.outputPollInterval = setInterval(() => {
+            this.drainOutputBuffer();
+        }, 16); // ~60fps
+    }
+
+    drainOutputBuffer() {
+        if (!this.outputRingBuffer) return;
+        
+        // Check for flush request from WASM side
+        const flushRequest = this.outputRingBuffer.view.getUint32(this.outputRingBuffer.controlOffset + 4, true);
+        if (flushRequest) {
+            // console.log('[JS_FLUSH] Detected flush request from WASM side');
+        }
+        
+        let output = '';
+        let charCount = 0;
+        while (this.outputRingBuffer.hasOutputData()) {
+            const char = this.outputRingBuffer.readOutputChar();
+            if (char) {
+                output += char;
+                charCount++;
+            }
+        }
+        
+        if (output.length > 0) {
+            this.terminal.write(output);
+        }
+        
+        // If there was a flush request, force terminal to flush and clear the request
+        if (flushRequest) {
+            // console.log('[JS_FLUSH] Processing flush request, output.length=' + output.length);
+            // Force immediate terminal update - this ensures characters appear right away
+            if (output.length > 0) {
+                // Terminal write is already called above, just ensure it's processed
+                setTimeout(() => {}, 0); // Allow browser to process the write immediately
+            }
+            // Clear the flush request
+            this.outputRingBuffer.view.setUint32(this.outputRingBuffer.controlOffset + 4, 0, true);
+            // console.log('[JS_FLUSH] Cleared flush request');
+        }
+    }
+
+    resetEmulator() {
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+        }
+
+        // Stop output polling
+        if (this.outputPollInterval) {
+            clearInterval(this.outputPollInterval);
+            this.outputPollInterval = null;
+        }
+
+        // Clean up shared resources
+        this.wasmMemory = null;
+        this.inputRingBuffer = null;
+        this.outputRingBuffer = null;
+        this.emulatorReady = false;
+        this.autoBootInProgress = false;
+        this._readyResolve = null;
+
+        this.terminal.clear();
+        this.terminal.writeln('\x1b[36mKLH10 PDP-10 Emulator - WebAssembly Port\x1b[0m');
+        this.terminal.writeln('Click "Boot TOPS-20" to begin...');
+        this.terminal.writeln('');
+
+        this.updateStatus('Ready to start emulator', 'ready');
+        document.getElementById('startBtn').disabled = false;
+        document.getElementById('resetBtn').disabled = true;
+        document.getElementById('loadConfigBtn').disabled = true;
+        document.getElementById('bootTops20Btn').disabled = true;
+        document.getElementById('autoBootBtn').disabled = false;
+        
+        // Focus terminal after reset
+        this.terminal.focus();
+    }
+
+    // --- Simple Mode (one-click boot) ---
+
+    waitForReady() {
+        if (this.emulatorReady) return Promise.resolve();
+        return new Promise((resolve) => {
+            this._readyResolve = resolve;
+        });
+    }
+
+    loadInstallationConfigAsync() {
+        return new Promise((resolve, reject) => {
+            if (!this.worker || !this.emulatorReady || !this.inputRingBuffer) {
+                reject(new Error('Emulator not ready'));
+                return;
+            }
+
+            fetch('tops20-config-commands.txt')
+                .then(response => {
+                    if (!response.ok) throw new Error('Could not load config commands file');
+                    return response.text();
+                })
+                .then(commandsText => {
+                    const lines = commandsText.split('\n');
+                    const configCommands = [];
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith(';')) {
+                            configCommands.push(trimmed);
+                        }
+                    }
+
+                    let delay = 0;
+                    configCommands.forEach((command, index) => {
+                        setTimeout(() => {
+                            const fullCommand = command + '\r';
+                            for (let i = 0; i < fullCommand.length; i++) {
+                                this.inputRingBuffer.writeInputChar(fullCommand[i]);
+                            }
+                            if (this.inRuncmdMode) {
+                                this.terminal.write(command + '\r\n');
+                            }
+                            if (index === configCommands.length - 1) {
+                                setTimeout(() => {
+                                    resolve();
+                                }, 100);
+                            }
+                        }, delay);
+                        delay += 500;
+                    });
+                })
+                .catch(reject);
+        });
+    }
+
+    bootTops20Async() {
+        return new Promise((resolve, reject) => {
+            if (!this.worker || !this.emulatorReady || !this.inputRingBuffer) {
+                reject(new Error('Emulator not ready'));
+                return;
+            }
+
+            fetch('tops20-boot-commands.txt')
+                .then(response => {
+                    if (!response.ok) throw new Error('Could not load boot commands file');
+                    return response.text();
+                })
+                .then(commandsText => {
+                    const lines = commandsText.split('\n');
+                    const bootCommands = [];
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (trimmed && !trimmed.startsWith('#')) {
+                            if (trimmed.startsWith('{')) {
+                                if (trimmed === '{date-time}') {
+                                    const now = new Date();
+                                    const day = now.getDate().toString().padStart(2, '0');
+                                    const months = ['JAN','FEB','MAR','APR','MAY','JUN',
+                                                   'JUL','AUG','SEP','OCT','NOV','DEC'];
+                                    const month = months[now.getMonth()];
+                                    const year = now.getFullYear();
+                                    const hours = now.getHours().toString().padStart(2, '0');
+                                    const minutes = now.getMinutes().toString().padStart(2, '0');
+                                    const dateTime = `${day}-${month}-${year} ${hours}${minutes}`;
+                                    bootCommands.push({ command: dateTime, noCr: true });
+                                } else if (trimmed === '{ctrl-c}') {
+                                    bootCommands.push({ command: '\x03', noCr: true });
+                                } else if (trimmed.match(/^\{wait \d+\}$/)) {
+                                    const waitMatch = trimmed.match(/^\{wait (\d+)\}$/);
+                                    bootCommands.push({ command: null, noCr: true, waitSeconds: parseInt(waitMatch[1], 10) });
+                                } else if (trimmed === '{echo on}') {
+                                    bootCommands.push({ command: null, noCr: true, echoControl: 'on' });
+                                } else if (trimmed === '{echo off}') {
+                                    bootCommands.push({ command: null, noCr: true, echoControl: 'off' });
+                                } else if (trimmed === '{cr}') {
+                                    bootCommands.push({ command: '\r', noCr: true });
+                                }
+                            } else {
+                                let processedCommand = trimmed;
+                                processedCommand = processedCommand.replace(/\{esc\}/g, '\x1b');
+                                const hasNoCr = processedCommand.includes('{nocr}');
+                                processedCommand = processedCommand.replace(/\{nocr\}/g, '');
+                                bootCommands.push({ command: processedCommand, noCr: hasNoCr });
+                            }
+                        }
+                    }
+
+                    this.executeCommandsSequentially(bootCommands, 0, resolve);
+                })
+                .catch(reject);
+        });
+    }
+
+    async autoBoot() {
+        this.autoBootInProgress = true;
+        document.getElementById('autoBootBtn').disabled = true;
+
+        try {
+            // Step 1: Start emulator
+            this.updateStatus('Initializing emulator... please wait', 'loading');
+            await this.startEmulator();
+
+            // Step 2: Wait for worker to be ready (loads WASM + disk image)
+            this.terminal.writeln('\x1b[33mPlease wait — loading disk image (~476 MB)...\x1b[0m');
+            await this.waitForReady();
+
+            // Step 3: Load config
+            this.updateStatus('Configuring virtual hardware... please wait', 'loading');
+            await this.loadInstallationConfigAsync();
+
+            // Step 4: Boot
+            this.updateStatus('Booting TOPS-20... please wait', 'loading');
+            this.terminal.writeln('\x1b[33mPlease wait — TOPS-20 is booting...\x1b[0m');
+            await this.bootTops20Async();
+
+            // Done
+            this.autoBootInProgress = false;
+            this.updateStatus('TOPS-20 ready', 'ready');
+            this.terminal.focus();
+        } catch (error) {
+            this.autoBootInProgress = false;
+            this.updateStatus(`Boot failed: ${error.message}`, 'error');
+            document.getElementById('autoBootBtn').disabled = false;
+            console.error('Auto-boot failed:', error);
+        }
+    }
+}
+
+// Initialize the interface when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+    new KLH10WebInterface();
+});

build/wasm/bld-kl/mtboot.sav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4a495622d642b926b87aa1ac63a7fd719cb1b27a877de4b1f8353a54735251e
+size 20460

build/wasm/bld-kl/serve.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const PORT = process.env.PORT || 8080;
+const HOSTNAME = '0.0.0.0'; // Allow external access
+
+// MIME types for web assets
+const mimeTypes = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.wasm': 'application/wasm',
+    '.css': 'text/css',
+    '.ico': 'image/x-icon',
+    '.tap': 'application/octet-stream',
+    '.sav': 'application/octet-stream'
+};
+
+// Special handling for Emscripten generated files
+const getContentType = (filePath) => {
+    const extname = path.extname(filePath);
+    const basename = path.basename(filePath);
+    
+    // Handle kn10-ks (Emscripten JS file without extension)
+    if (basename === 'kn10-ks' || basename.startsWith('kn10-') && !extname) {
+        return 'application/javascript';
+    }
+    
+    return mimeTypes[extname] || 'text/plain';
+};
+
+const server = http.createServer((req, res) => {
+    // Remove query parameters for file lookup
+    const urlPath = req.url.split('?')[0];
+    let filePath = path.join(__dirname, urlPath === '/' ? 'index.html' : urlPath);
+    
+    // Security: prevent directory traversal
+    if (!filePath.startsWith(__dirname)) {
+        res.writeHead(403);
+        res.end('Forbidden');
+        return;
+    }
+
+    const contentType = getContentType(filePath);
+
+    fs.readFile(filePath, (error, content) => {
+        if (error) {
+            if (error.code === 'ENOENT') {
+                res.writeHead(404);
+                res.end('File not found');
+            } else {
+                res.writeHead(500);
+                res.end('Server error: ' + error.code);
+            }
+        } else {
+            // Set CORS headers for SharedArrayBuffer support
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Cross-Origin-Embedder-Policy', 'require-corp');
+            res.setHeader('Cross-Origin-Opener-Policy', 'same-origin');
+            
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+    });
+});
+
+server.listen(PORT, HOSTNAME, () => {
+    console.log(`🚀 KLH10 WebAssembly Emulator Server`);
+    console.log(`📡 Serving at http://${HOSTNAME}:${PORT}/`);
+    console.log(`🌐 Open in browser to start the PDP-10 emulator`);
+    console.log(`📁 Serving files from: ${__dirname}`);
+    console.log('');
+    console.log('Press Ctrl+C to stop the server');
+});
+
+process.on('SIGTERM', () => {
+    console.log('\\n👋 Server shutting down...');
+    server.close(() => {
+        console.log('✅ Server stopped');
+        process.exit(0);
+    });
+});

build/wasm/bld-kl/tops20-boot-commands.txt

@@ -0,0 +1,33 @@
+# TOPS-20 Boot Commands for KLH10 WebAssembly
+# Based on doc/kst20.txt installation sequence
+#
+# Available script commands:
+# {date-time} - Insert current date/time in TOPS-20 format (DD-MMM-YYYY HHMM)
+# {ctrl-c}    - Send CTRL-C character (ASCII 3)
+# {wait #}    - Wait for # seconds before continuing (e.g. {wait 3})
+# {esc}       - Insert ESC character (ASCII 27) - can be used inline
+# {nocr}      - Don't add carriage return (\r) at end of command - can be used inline
+# {echo on}   - Enable terminal echo (keyboard input is displayed)
+# {echo off}  - Disable terminal echo (keyboard input is not displayed)
+# {cr}        - Send carriage return (\r) character
+#
+# Notes:
+# - Lines starting with # are comments and ignored
+# - Empty lines are ignored  
+# - {esc} and {nocr} can be used anywhere within a command line; others must be at start of line
+# - {nocr} prevents the automatic \r that is normally added to each command
+# - Terminal echo is enabled by default; use {echo off} to hide typed input
+# - {echo on/off} only affect keyboard input visibility, not script commands
+# 0. GO
+go
+{echo off}
+{cr}
+{wait 5}
+new
+{wait 1}
+no
+{wait 10}
+{ctrl-c}
+log operator dec-20
+enable
+terminal vt100

build/wasm/bld-kl/tops20-config-commands.txt

@@ -0,0 +1,27 @@
+; Define basic device config - one DTE, one disk, one tape
+devdef dte0 200   dte	master
+devdef rh0  540   rh20
+devdef rh1  544   rh20
+devdef dsk0 rh0.0 rp	type=rp07 format=dbd9
+devdef mta0 rh1.0 tm03	type=tu45
+
+; Ethernet interface disabled for WebAssembly build
+; devdef ni0 564 ni20 ipaddr=127.0.0.1 debug=1
+
+; Define the idle device on 700
+devdef idler 700 host
+
+; Set switch register
+set sw=254200,,147
+
+; Set console lights I/O base register
+;Uncomment the following line if you have a Panda display.
+;lights 378
+
+; Mount disk image file to disk drive
+devmount dsk0 RH20.RP07.1
+
+; Load disk bootstrap directly
+load boot.sav
+
+; Ready to GO

download-images.sh

@@ -0,0 +1,160 @@
+#!/bin/bash
+# download-images.sh — Downloads TOPS-20 disk and tape images for KLH10 WASM builds
+#
+# These are historical DEC and community-maintained software distribution images.
+# All files are freely available from public PDP-10 preservation archives.
+#
+# Sources:
+#   - DEC TOPS-20 tapes: http://pdp-10.trailing-edge.com/tapes/
+#   - Panda TOPS-20 distribution: https://panda.trailing-edge.com/
+#   - Panda tape image: https://github.com/PDP-10/panda
+#
+# Requirements: curl, bunzip2, tar
+#
+# Verified checksums (MD5):
+#   RH20.RP07.1        1cee5bd59bfcf0a0876360c195293998
+#   bb-h137f-bm.tap    a82ad1f21d28dd5bd905fe24b789eb5c
+#   panda.tap           c543517319a2b37025531f7d798ebb74
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+BLD_KL="$SCRIPT_DIR/build/wasm/bld-kl"
+BLD_KS="$SCRIPT_DIR/build/wasm/bld-ks"
+TAPES_DIR="$SCRIPT_DIR/tapes"
+TMPDIR="${TMPDIR:-/tmp}/klh10-download-$$"
+
+# Expected MD5 checksums
+MD5_RH20="1cee5bd59bfcf0a0876360c195293998"
+MD5_BB_H137F="a82ad1f21d28dd5bd905fe24b789eb5c"
+MD5_PANDA_TAP="c543517319a2b37025531f7d798ebb74"
+
+cleanup() {
+    rm -rf "$TMPDIR"
+}
+trap cleanup EXIT
+
+check_md5() {
+    local file="$1"
+    local expected="$2"
+    local actual
+    actual=$(md5sum "$file" | cut -d' ' -f1)
+    if [ "$actual" = "$expected" ]; then
+        echo "  checksum OK: $actual"
+        return 0
+    else
+        echo "  checksum MISMATCH: expected $expected, got $actual"
+        return 1
+    fi
+}
+
+echo "=============================================="
+echo "KLH10 TOPS-20 Image Downloader"
+echo "=============================================="
+echo ""
+
+# Check prerequisites
+for cmd in curl bunzip2 tar md5sum; do
+    if ! command -v "$cmd" >/dev/null 2>&1; then
+        echo "ERROR: Required command '$cmd' not found. Please install it."
+        exit 1
+    fi
+done
+
+mkdir -p "$TMPDIR"
+mkdir -p "$BLD_KL"
+
+# -----------------------------------------------
+# 1. Download RH20.RP07.1 (Panda TOPS-20 pre-installed disk image)
+#    Source: Mark Crispin's Panda distribution
+#    From: https://panda.trailing-edge.com/panda-dist.tar.gz
+# -----------------------------------------------
+if [ -f "$BLD_KL/RH20.RP07.1" ]; then
+    echo "[1/3] RH20.RP07.1 already exists in $BLD_KL/, verifying..."
+    check_md5 "$BLD_KL/RH20.RP07.1" "$MD5_RH20" || {
+        echo "  Existing file has wrong checksum, re-downloading..."
+        rm -f "$BLD_KL/RH20.RP07.1"
+    }
+fi
+
+if [ ! -f "$BLD_KL/RH20.RP07.1" ]; then
+    echo "[1/3] Downloading Panda distribution (221 MB compressed)..."
+    echo "  Source: https://panda.trailing-edge.com/panda-dist.tar.gz"
+    echo "  This is Mark Crispin's enhanced TOPS-20 with pre-installed system on RP07 disk."
+    curl -L --progress-bar -o "$TMPDIR/panda-dist.tar.gz" \
+        "https://panda.trailing-edge.com/panda-dist.tar.gz"
+
+    echo "  Extracting RH20.RP07.1 (476 MB)..."
+    tar xzf "$TMPDIR/panda-dist.tar.gz" -C "$TMPDIR" panda-dist/RH20.RP07.1
+    mv "$TMPDIR/panda-dist/RH20.RP07.1" "$BLD_KL/RH20.RP07.1"
+    rm -f "$TMPDIR/panda-dist.tar.gz"
+    rm -rf "$TMPDIR/panda-dist"
+
+    echo "  Verifying RH20.RP07.1..."
+    check_md5 "$BLD_KL/RH20.RP07.1" "$MD5_RH20"
+fi
+echo ""
+
+# -----------------------------------------------
+# 2. Copy boot.sav and mtboot.sav from source tree
+#    These are small files already in the repository.
+#    boot.sav = disk bootstrap loader (23 KB)
+#    mtboot.sav = tape bootstrap loader (20 KB)
+# -----------------------------------------------
+echo "[2/3] Copying bootstrap loaders from run/klt20/..."
+if [ -f "$SCRIPT_DIR/run/klt20/boot.sav" ]; then
+    cp "$SCRIPT_DIR/run/klt20/boot.sav" "$BLD_KL/boot.sav"
+    echo "  boot.sav copied ($(du -h "$BLD_KL/boot.sav" | cut -f1))"
+else
+    echo "  WARNING: run/klt20/boot.sav not found"
+fi
+if [ -f "$SCRIPT_DIR/run/klt20/mtboot.sav" ]; then
+    cp "$SCRIPT_DIR/run/klt20/mtboot.sav" "$BLD_KL/mtboot.sav"
+    echo "  mtboot.sav copied ($(du -h "$BLD_KL/mtboot.sav" | cut -f1))"
+else
+    echo "  WARNING: run/klt20/mtboot.sav not found"
+fi
+echo ""
+
+# -----------------------------------------------
+# 3. Download bb-h137f-bm.tap (DEC TOPS-20 V7.0 installation tape)
+#    Source: DEC distribution BB-H137F-BM, "TOPS-20 V7.0 INSTL 16MT9"
+#    From: http://pdp-10.trailing-edge.com/tapes/
+#    Note: Not required for normal boot (we boot from disk), but useful
+#    for fresh TOPS-20 installations from tape.
+# -----------------------------------------------
+if [ -f "$BLD_KL/bb-h137f-bm.tap" ]; then
+    echo "[3/3] bb-h137f-bm.tap already exists, verifying..."
+    check_md5 "$BLD_KL/bb-h137f-bm.tap" "$MD5_BB_H137F" || {
+        echo "  Existing file has wrong checksum, re-downloading..."
+        rm -f "$BLD_KL/bb-h137f-bm.tap"
+    }
+fi
+
+if [ ! -f "$BLD_KL/bb-h137f-bm.tap" ]; then
+    echo "[3/3] Downloading DEC TOPS-20 V7.0 install tape (8.5 MB compressed)..."
+    echo "  Source: http://pdp-10.trailing-edge.com/tapes/bb-h137f-bm.tap.bz2"
+    echo "  DEC part number BB-H137F-BM, 'TOPS-20 V7.0 INSTL 16MT9', copyright 1988 DEC."
+    curl -L --progress-bar -o "$TMPDIR/bb-h137f-bm.tap.bz2" \
+        "http://pdp-10.trailing-edge.com/tapes/bb-h137f-bm.tap.bz2"
+    bunzip2 "$TMPDIR/bb-h137f-bm.tap.bz2"
+    mv "$TMPDIR/bb-h137f-bm.tap" "$BLD_KL/bb-h137f-bm.tap"
+
+    echo "  Verifying bb-h137f-bm.tap..."
+    check_md5 "$BLD_KL/bb-h137f-bm.tap" "$MD5_BB_H137F"
+fi
+echo ""
+
+# -----------------------------------------------
+# Summary
+# -----------------------------------------------
+echo "=============================================="
+echo "Download complete! Files in $BLD_KL/:"
+echo "=============================================="
+ls -lh "$BLD_KL/RH20.RP07.1" "$BLD_KL/boot.sav" "$BLD_KL/mtboot.sav" "$BLD_KL/bb-h137f-bm.tap" 2>/dev/null
+echo ""
+echo "To run the emulator:"
+echo "  cd build/wasm/bld-kl"
+echo "  node serve.js"
+echo "  # Open http://localhost:8080"
+echo "  # Click 'Boot TOPS-20' and wait ~30 seconds"

run/klt20/boot.sav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2e0c3d1ea76b81fa1c5aaa8b3922acacc7e87f168befa35f4867939389f764f
+size 23280

run/klt20/mtboot.sav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4a495622d642b926b87aa1ac63a7fd719cb1b27a877de4b1f8353a54735251e
+size 20460