c64bridge 1.0.5 → 1.0.6

package/dist/c64Client.js

@@ -11,8 +11,9 @@ import { createSocket } from "node:dgram";
 import { networkInterfaces } from "node:os";
 import axios from "axios";
 import { basicToPrg } from "./tools/translation/basicTokenizer.js";
-import { assemblyToPrg, prgEntryAddress } from "./tools/translation/assembler.js";
+import { assemblyToPrgDetailed, prgEntryAddress } from "./tools/translation/assembler.js";
 import { stripHexByteSeparators } from "./tools/hex.js";
+import { SIDWAVE_PLAY_ADDRESS } from "./sidwaveCompiler.js";
 import { petsciiToAscii, screenCodesToAscii } from "./petscii.js";
 import { resolveAddressSymbol } from "./knowledge.js";
 import { createAllFacades, createFacade, } from "./device.js";
@@ -33,6 +34,8 @@ export class KeyboardQueueDrainTimeoutError extends Error {
         this.timeoutMs = timeoutMs;
     }
 }
+/** JOYPORT_ID_IO_SIMULATION in joyport.h (the same in VICE 3.9 and 3.10). */
+const VICE_JOYPORT_IO_SIMULATION = 37;
 const C64U_SYSTEM_MODE_CATEGORY = "U64 Specific Settings";
 const C64U_SYSTEM_MODE_ITEM = "System Mode";
 // System Mode values that run the machine clock at the NTSC frequency
@@ -184,6 +187,8 @@ export class C64Client {
         this.greetingDd00Warmups = new Map();
         this.machineInputCapabilityProbes = new Map();
         this.c64uVideoCaptureSession = null;
+        /** VICE joyport device ids to restore when a joystick press ends. */
+        this.viceJoyportSavedDevice = new Map();
         this.activeType = "c64u";
         this.baseUrl = baseUrl;
         const headers = options.networkPassword ? { "X-Password": options.networkPassword } : undefined;
@@ -545,16 +550,17 @@ export class C64Client {
      * range corrupts the workspace. Instead this loads the assembled bytes
      * without running them, then types `SYS <entry>` to transfer control
      * to the entry point: the target of a leading SYS stub at $0801, or else
-     * the lowest assembled address.
+     * the first assembled instruction.
      */
     async uploadAndRunAsm(program) {
         try {
-            const prg = assemblyToPrg(program);
+            const assembled = assemblyToPrgDetailed(program);
+            const prg = assembled.prg;
             if (prg.length < 2) {
                 return { success: false, details: { message: "Assembled program produced no output" } };
             }
-            const entryAddress = prgEntryAddress(prg);
-            if (entryAddress === 0x0801) {
+            const entryAddress = assembled.entryAddress;
+            if (prg.readUInt16LE(0) === 0x0801 && prgEntryAddress(prg) === 0x0801) {
                 // Loading makes BASIC relink $0801 as program lines, which overwrites raw code there.
                 return {
                     success: false,
@@ -763,24 +769,48 @@ export class C64Client {
     async sidReset(hard = false) {
         try {
             const facade = await this.facadePromise;
+            // Unhooking a running SIDWAVE player is best-effort: a failed read must not stop the SID being silenced.
+            const stoppedSidwavePlayer = await this.stopSidwaveIrqPlayer(facade).catch(() => false);
             if (hard) {
                 const span = 0x19;
                 const ff = Buffer.alloc(span, 0xff);
                 const zz = Buffer.alloc(span, 0x00);
                 await facade.writeMemory(0xd400, ff);
                 await facade.writeMemory(0xd400, zz);
-                return { success: true };
+                return { success: true, ...(stoppedSidwavePlayer ? { details: { stoppedSidwavePlayer } } : {}) };
             }
             await facade.writeMemory(0xd404, Buffer.from([0x00]));
             await facade.writeMemory(0xd40b, Buffer.from([0x00]));
             await facade.writeMemory(0xd412, Buffer.from([0x00]));
             await facade.writeMemory(0xd418, Buffer.from([0x00]));
-            return { success: true };
+            return { success: true, ...(stoppedSidwavePlayer ? { details: { stoppedSidwavePlayer } } : {}) };
         }
         catch (error) {
             return { success: false, details: this.normaliseError(error) };
         }
     }
+    /**
+     * A SIDWAVE PRG keeps playing from the IRQ after the SID is silenced. Its
+     * IRQ handler is "JSR play / JMP $EA31", and its play vector at $0813 is
+     * "JMP play". When $0314 points at such a handler, point it back at the
+     * KERNAL handler so silencing sticks; other programs' IRQ handlers are left
+     * alone. Both vector bytes go in one write.
+     */
+    async stopSidwaveIrqPlayer(facade) {
+        const vector = await facade.readMemory(0x0314, 2);
+        const handler = (vector[0] ?? 0) | ((vector[1] ?? 0) << 8);
+        // A handler too close to $FFFF cannot hold the 6-byte SIDWAVE handler (and the read would cross $FFFF).
+        if (handler === 0xea31 || handler > 0xfffa)
+            return false;
+        const code = await facade.readMemory(handler, 6);
+        const playVector = await facade.readMemory(SIDWAVE_PLAY_ADDRESS, 3);
+        const isSidwaveHandler = code[0] === 0x20 && code[3] === 0x4c && code[4] === 0x31 && code[5] === 0xea
+            && playVector[0] === 0x4c && playVector[1] === code[1] && playVector[2] === code[2];
+        if (!isSidwaveHandler)
+            return false;
+        await facade.writeMemory(0x0314, Uint8Array.of(0x31, 0xea));
+        return true;
+    }
     async sidNoteOn(options, pinnedFacade) {
         const voice = options.voice ?? 1;
         if (voice < 1 || voice > 3) {
@@ -789,6 +819,15 @@ export class C64Client {
         const system = options.system ?? "PAL";
         // The tool schema documents that a note name overrides frequencyHz.
         const hz = options.note ? this.noteNameToHz(options.note) : options.frequencyHz ?? 440;
+        // The 16-bit frequency register tops out at about 3848 Hz on PAL and 3995 Hz
+        // on NTSC (B7 is already above the PAL limit); report it instead of clamping.
+        const maxHz = (0xffff * (system === "PAL" ? 985248 : 1022727)) / 16777216;
+        if (hz > maxHz + 0.5) {
+            return {
+                success: false,
+                details: { message: `${options.note ?? `${hz} Hz`} (${hz.toFixed(1)} Hz) is above the SID's highest ${system} frequency of ${maxHz.toFixed(1)} Hz` },
+            };
+        }
         const freq16 = this.hzToSidFrequency(hz, system);
         const freqLo = freq16 & 0xff;
         const freqHi = (freq16 >> 8) & 0xff;
@@ -1971,6 +2010,43 @@ export class C64Client {
     async viceJoyportSet(port, activeLowMask) {
         await this.withViceMonitor((client) => client.joyportSet(port, activeLowMask));
     }
+    /**
+     * Hold joystick lines on a VICE control port. Binary Monitor command 0xA2
+     * only drives VICE's "I/O simulation" joyport device, so that device is
+     * attached for the duration of the press and the previous device is
+     * restored on release. The device reads bits 5-7 as low, which the
+     * keyboard scan sees as extra keys, so it must not stay attached.
+     *
+     * While a press is held: on port 1 the keyboard scan sees phantom keys
+     * (for example SHIFT+C=, which toggles the character set); on port 2,
+     * $DC00 reads with bits 5-7 clear (up = $1E where a joystick gives $7E),
+     * so programs that compare the whole byte will not see the input.
+     */
+    async viceJoystickPress(port, activeLowMask) {
+        await this.withViceMonitor(async (client) => {
+            const resource = `JoyPort${port}Device`;
+            // Read the device every time: after a VICE restart the saved state is stale.
+            const current = await client.resourceGet(resource);
+            const currentId = current.type === "int" ? current.value : Number(current.value);
+            if (currentId !== VICE_JOYPORT_IO_SIMULATION) {
+                this.viceJoyportSavedDevice.set(port, currentId);
+                await client.resourceSet(resource, VICE_JOYPORT_IO_SIMULATION);
+            }
+            // Attaching the device clears its lines to 0 (everything pressed), so set them in the same monitor session.
+            await client.joyportSet(port, activeLowMask);
+        });
+    }
+    /** Release a VICE control port and restore the joyport device it had before the press. */
+    async viceJoystickRelease(port) {
+        await this.withViceMonitor(async (client) => {
+            await client.joyportSet(port, 0xff);
+            const saved = this.viceJoyportSavedDevice.get(port);
+            if (saved !== undefined) {
+                await client.resourceSet(`JoyPort${port}Device`, saved);
+                this.viceJoyportSavedDevice.delete(port);
+            }
+        });
+    }
     async viceMemGet(address, length) {
         const end = (address + length - 1) & 0xffff;
         return this.withViceMonitor((client) => client.memGet(address, end));
@@ -2269,86 +2345,6 @@ function buildGreetingScreenRam(message) {
     writeScreenLine(screenRam, 3, "READY.");
     return screenRam;
 }
-function buildSingleSpriteProgram(opts) {
-    const index = Math.max(0, Math.min(7, opts.spriteIndex ?? 0));
-    const mx = Math.max(0, Math.min(511, opts.x ?? 100));
-    const xLo = mx & 0xff;
-    const xMsbBit = (mx & 0x100) ? (1 << index) : 0;
-    const y = toByte(opts.y, 100);
-    const color = toByte(opts.color, 1);
-    const multicolour = !!opts.multicolour;
-    const spriteData = Buffer.from(opts.spriteBytes);
-    if (spriteData.length !== 63) {
-        throw new Error("spriteBytes must be exactly 63 bytes");
-    }
-    // We'll assemble a tiny machine-code program that:
-    // - Copies 63 bytes to a safe sprite data page ($2000 by default)
-    // - Sets screen memory base to $0400, sprite pointer to point into $2000
-    // - Positions and enables the sprite
-    // - Loops forever
-    // This avoids relying on KERNAL calls and works from a cold start.
-    const SPRITE_BASE = 0x2000; // must be 64-byte aligned
-    const POINTER_PAGE = 0x07f8 + index; // sprite pointer table location
-    const pointerValue = (SPRITE_BASE >> 6) & 0xff;
-    // Place code starting at $0801 so it runs as a program via SYS.
-    // We'll create an assembler source and reuse assemblyToPrg.
-    const lines = [];
-    lines.push("* = $0801");
-    // Tiny BASIC loader header not needed; we will use pure ML and jump via RESET runner which executes by SYS 2061
-    // Build code at $0810 to avoid conflicting with potential KERNAL vectors
-    lines.push("* = $0810");
-    lines.push("\nstart:");
-    // Copy 63 bytes from inlined table to SPRITE_BASE
-    lines.push("  LDY #$00");
-    lines.push("copy_loop:");
-    lines.push("  LDA sprite_data,Y");
-    lines.push(`  STA $${hex16(SPRITE_BASE)},Y`);
-    lines.push("  INY");
-    lines.push("  CPY #$3F");
-    lines.push("  BNE copy_loop");
-    // Set sprite pointer, color, coordinates, enable
-    lines.push(`  LDA #$${pointerValue.toString(16).toUpperCase().padStart(2, "0")}`);
-    lines.push(`  STA $${(POINTER_PAGE).toString(16).toUpperCase()}`);
-    lines.push(`  LDA #$${color.toString(16).toUpperCase().padStart(2, "0")}`);
-    lines.push(`  STA $${hex16(0xD027 + index)}`);
-    lines.push(`  LDA #$${xLo.toString(16).toUpperCase().padStart(2, "0")}`);
-    lines.push(`  STA $${(0xD000 + index * 2).toString(16).toUpperCase()}`);
-    lines.push(`  LDA #$${y.toString(16).toUpperCase().padStart(2, "0")}`);
-    lines.push(`  STA $${(0xD001 + index * 2).toString(16).toUpperCase()}`);
-    // MSB X if needed
-    if (xMsbBit) {
-        const bit = xMsbBit;
-        lines.push(`  LDA $D010`);
-        lines.push(`  ORA #$${bit.toString(16).toUpperCase().padStart(2, "0")}`);
-        lines.push(`  STA $D010`);
-    }
-    // Multicolour toggle per-sprite
-    if (multicolour) {
-        const bit = 1 << index;
-        lines.push(`  LDA $D01C`);
-        lines.push(`  ORA #$${bit.toString(16).toUpperCase().padStart(2, "0")}`);
-        lines.push(`  STA $D01C`);
-    }
-    // Enable sprite
-    {
-        const bit = 1 << index;
-        lines.push(`  LDA $D015`);
-        lines.push(`  ORA #$${bit.toString(16).toUpperCase().padStart(2, "0")}`);
-        lines.push(`  STA $D015`);
-    }
-    // Idle loop
-    lines.push("forever: JMP forever");
-    // Sprite data table
-    lines.push("\nsprite_data:");
-    for (let i = 0; i < 63; i += 3) {
-        const a = spriteData[i] ?? 0;
-        const b = spriteData[i + 1] ?? 0;
-        const c = spriteData[i + 2] ?? 0;
-        lines.push(`  .byte $${hex2(a)},$${hex2(b)},$${hex2(c)}`);
-    }
-    const source = lines.join("\n");
-    return assemblyToPrg(source, { fileName: "sprite_gen.asm", loadAddress: 0x0801 });
-}
 export function buildPetsciiScreenBasic(opts) {
     const border = toByte(opts.borderColor ?? 6); // default blue-ish
     const bg = toByte(opts.backgroundColor ?? 0); // default black
@@ -2548,9 +2544,3 @@ export function buildCommodoreDllBasicProgram(opts) {
     lines.push(`${ln} CLOSE1`);
     return lines.join("\n");
 }
-function hex2(n) {
-    return (n & 0xff).toString(16).toUpperCase().padStart(2, "0");
-}
-function hex16(n) {
-    return (n & 0xffff).toString(16).toUpperCase().padStart(4, "0");
-}

package/dist/config.js

@@ -114,13 +114,28 @@ export function resolveUltimateEndpoint(profile, section, legacy) {
         ...parsedBaseOverrides.map((entry) => entry.port),
     ];
     const host = firstDefined(...hostCandidates) ?? DEFAULT_HOST;
-    const port = firstDefined(...portCandidates) ?? DEFAULT_PORT;
+    // When the host comes from a baseUrl, keep its scheme and path (for example
+    // https://proxy/c64u), applying only an explicit port override. An explicit
+    // host builds http://host:port as documented.
+    const baseOnly = parsedBaseOverrides.find((entry) => entry.hostname !== undefined);
+    const explicitHost = firstDefined(...hostCandidates.slice(0, -parsedBaseOverrides.length));
+    const explicitPort = firstDefined(...portCandidates.slice(0, -parsedBaseOverrides.length));
+    const keepBaseUrl = baseOnly?.fullUrl !== undefined && explicitHost === undefined;
+    const schemeDefaultPort = keepBaseUrl && baseOnly.fullUrl.startsWith("https:") ? 443 : DEFAULT_PORT;
+    const port = firstDefined(...portCandidates) ?? schemeDefaultPort;
     const hostLabel = formatHost(host);
+    let baseUrl = buildBaseUrl(host, port);
+    if (keepBaseUrl) {
+        const url = new URL(baseOnly.fullUrl);
+        if (explicitPort !== undefined)
+            url.port = String(explicitPort);
+        baseUrl = stripTrailingSlash(url.toString());
+    }
     return {
         host,
         port,
-        baseUrl: buildBaseUrl(host, port),
-        c64_host: port === DEFAULT_PORT ? hostLabel : `${hostLabel}:${port}`,
+        baseUrl,
+        c64_host: port === schemeDefaultPort ? hostLabel : `${hostLabel}:${port}`,
         networkPassword: firstDefined(nonEmptyString(envPassword), nonEmptyString(section?.networkPassword), nonEmptyString(legacy?.networkPassword)),
     };
 }
@@ -181,7 +196,9 @@ function parseEndpoint(value) {
         const hostname = url.hostname || undefined;
         const port = url.port ? configuredPort(url.port) : undefined;
         const baseUrl = stripTrailingSlash(`${url.protocol}//${url.host}`);
-        return { hostname, port, baseUrl };
+        // Scheme and path prefix kept, for an Ultimate reached through a reverse proxy.
+        const fullUrl = stripTrailingSlash(`${url.protocol}//${url.host}${url.pathname}`);
+        return { hostname, port, baseUrl, fullUrl };
     }
     catch {
         return {};

package/dist/device.js

@@ -9,6 +9,7 @@ import { Api } from "../generated/c64/index.js";
 import { createLoggingHttpClient } from "./loggingHttpClient.js";
 import { ViceClient } from "./vice/viceClient.js";
 import { waitForBasicReady } from "./vice/readiness.js";
+import { screenCodesToAscii } from "./petscii.js";
 import { startViceProcess } from "./vice/process.js";
 import { loadConfig, resolveUltimateEndpoint } from "./config.js";
 const DEFAULT_VICE_HOST = "127.0.0.1";
@@ -302,6 +303,12 @@ export class ViceBackend {
         this.startupPromise = null;
         this.monitorQueue = Promise.resolve();
         this.lastProcessStart = 0;
+        // VICE has no "drive enabled" or "attached image" resource. A drive is off
+        // when Drive<n>Type is 0, and images attached through this backend are
+        // remembered here because VICE cannot report them.
+        this.attachedImages = new Map();
+        this.savedDriveTypes = new Map();
+        this.trackedStateProcessStart = 0;
         ViceBackend.ensureCleanupRegistration();
         const envBinary = configuredString(process.env.VICE_BINARY);
         const configBinary = config.exe !== undefined
@@ -734,19 +741,27 @@ export class ViceBackend {
     getEndpoint() {
         return { host: this.host, port: this.port };
     }
+    /** A restarted VICE has no images attached and default drive types, so forget what was tracked before. */
+    syncTrackedState() {
+        if (this.trackedStateProcessStart !== this.lastProcessStart) {
+            this.attachedImages.clear();
+            this.savedDriveTypes.clear();
+            this.trackedStateProcessStart = this.lastProcessStart;
+        }
+    }
     async drivesList() {
+        this.syncTrackedState();
         return await this.withClient(async (client) => {
             const drives = [];
             for (const n of [8, 9, 10, 11]) {
                 try {
-                    const enabled = await client.resourceGet(`Drive${n}CPUEnabled`);
-                    const image = await client.resourceGet(`Drive${n}Image`);
                     const typeRes = await client.resourceGet(`Drive${n}Type`);
+                    const type = typeRes.type === "int" ? typeRes.value : Number(typeRes.value);
                     drives.push({
                         id: `drive${n}`,
-                        power: (typeof enabled.value === "number" ? enabled.value : 0) ? "on" : "off",
-                        image: typeof image.value === "string" && image.value ? image.value : null,
-                        type: typeRes.value,
+                        power: type !== 0 ? "on" : "off",
+                        image: this.attachedImages.get(n) ?? null,
+                        type,
                     });
                 }
                 catch {
@@ -761,44 +776,83 @@ export class ViceBackend {
             throw unsupported("driveMount type/mode overrides; omit these options on VICE");
         }
         const n = parseDriveNumber(drive);
-        await this.withClient(async (client) => {
-            await client.resourceSet(`Drive${n}CPUEnabled`, 1);
-            await client.resourceSet(`Drive${n}Image`, imagePath);
+        if (n !== 8) {
+            // The Binary Monitor's only attach path is autostart, which always uses drive 8.
+            throw unsupported(`driveMount on drive ${n}; VICE can attach images over the Binary Monitor only to drive 8`);
+        }
+        // Autostart falls back to tape, snapshot, cartridge and PRG handling when a
+        // file is not a disk image, so only disk images are passed on.
+        if (!VICE_DISK_IMAGE_EXTENSIONS.has(path.extname(imagePath).toLowerCase())) {
+            throw new Error(`VICE can mount only disk images (${[...VICE_DISK_IMAGE_EXTENSIONS].join(", ")}): ${imagePath}`);
+        }
+        if (!fs.existsSync(imagePath)) {
+            throw new Error(`Disk image not found on the VICE host: ${imagePath}`);
+        }
+        const outcome = await this.withClient(async (client) => {
+            // Sync after withClient has started VICE, or a start here would clear this mount's record.
+            this.syncTrackedState();
+            await this.ensureDriveOn(client, n);
+            await client.memSet(AUTOLOAD_MARKER_ADDRESS, AUTOLOAD_MARKER);
+            await client.autostart(imagePath, { run: false });
+            // Autoload power-cycles the machine after this call returns; wait until
+            // its LOAD has finished so callers do not write into a machine that is
+            // about to be reset.
+            return waitForAutoloadFinished(client, 30000);
         });
-        return { success: true, details: { drive, image: imagePath } };
+        this.attachedImages.set(n, imagePath);
+        return {
+            success: true,
+            details: {
+                drive,
+                image: imagePath,
+                loadedFirstProgram: outcome.loaded,
+                note: outcome.loaded
+                    ? "VICE attaches images through autoload, which resets the machine (clearing RAM) and LOADs the first program without running it."
+                    : "VICE attaches images through autoload, which resets the machine (clearing RAM); the disk has no program to load.",
+            },
+        };
     }
-    async driveRemove(drive) {
-        const n = parseDriveNumber(drive);
-        await this.withClient(async (client) => {
-            await client.resourceSet(`Drive${n}Image`, "");
-        });
-        return { success: true, details: { drive } };
+    async driveRemove(_drive) {
+        throw unsupported("driveRemove; the VICE Binary Monitor has no command to detach a disk image");
     }
     async driveReset(drive) {
         const n = parseDriveNumber(drive);
         await this.withClient(async (client) => {
-            await client.resourceSet(`Drive${n}CPUEnabled`, 0);
-            await client.resourceSet(`Drive${n}CPUEnabled`, 1);
+            await client.resetDrive(n);
         });
         return { success: true, details: { drive } };
     }
     async driveOn(drive) {
         const n = parseDriveNumber(drive);
         await this.withClient(async (client) => {
-            await client.resourceSet(`Drive${n}CPUEnabled`, 1);
+            await this.ensureDriveOn(client, n);
         });
         return { success: true, details: { drive, power: "on" } };
     }
     async driveOff(drive) {
         const n = parseDriveNumber(drive);
+        this.syncTrackedState();
         await this.withClient(async (client) => {
-            await client.resourceSet(`Drive${n}CPUEnabled`, 0);
+            const current = await client.resourceGet(`Drive${n}Type`);
+            const type = current.type === "int" ? current.value : Number(current.value);
+            if (type !== 0)
+                this.savedDriveTypes.set(n, type);
+            await client.resourceSet(`Drive${n}Type`, 0);
         });
         return { success: true, details: { drive, power: "off" } };
     }
+    /** Switch a drive on by giving it a type again: the one it had before driveOff, or a 1541. */
+    async ensureDriveOn(client, n) {
+        const current = await client.resourceGet(`Drive${n}Type`);
+        const type = current.type === "int" ? current.value : Number(current.value);
+        if (type === 0) {
+            await client.resourceSet(`Drive${n}Type`, this.savedDriveTypes.get(n) ?? 1541);
+        }
+    }
     async driveSetMode(drive, mode) {
         const n = parseDriveNumber(drive);
-        const DRIVE_TYPE = { "1541": 2, "1571": 8, "1581": 11 };
+        // Drive<n>Type takes the model number itself (DRIVE_TYPE_1541 = 1541 in VICE's drive.h).
+        const DRIVE_TYPE = { "1541": 1541, "1571": 1571, "1581": 1581 };
         const typeNum = DRIVE_TYPE[mode];
         if (typeNum === undefined)
             throw new Error(`Unknown drive mode: ${mode}`);
@@ -815,10 +869,11 @@ export class ViceBackend {
             categories: [
                 {
                     name: "VICE",
+                    // Only resources that exist in VICE 3.10; checked against a running x64sc.
+                    // VICE has no warp, drive-enable or attached-image resources.
                     items: [
-                        "WarpMode", "SoundVolume", "Drive8CPUEnabled", "Drive9CPUEnabled",
-                        "Drive10CPUEnabled", "Drive11CPUEnabled", "Drive8Image", "Drive9Image",
-                        "Drive8Type", "Drive9Type", "VICIIBorderMode", "VICIIFullscreen",
+                        "SoundVolume", "Drive8Type", "Drive9Type", "Drive10Type", "Drive11Type",
+                        "VICIIBorderMode", "VICIIFullscreen", "MachineVideoStandard", "SidModel",
                     ],
                 },
             ],
@@ -894,12 +949,63 @@ function parseViceConfigValue(value, type, item) {
     }
     return parsed;
 }
-function unsupported(name) { const err = new Error(`Operation '${name}' is not supported by the VICE backend in phase one`); err.code = "UNSUPPORTED"; return err; }
+function unsupported(name) { const err = new Error(`Operation '${name}' is not supported by the VICE backend`); err.code = "UNSUPPORTED"; return err; }
 /** Ultimate file APIs treat slash as a path separator. Encode each name once,
  * preserving leading and nested separators for firmware routing. */
 function encodeDevicePath(value) {
     return value.split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
+/** Disk image types VICE's drive 8 can attach (autostart would treat anything else as tape, cartridge or PRG). */
+const VICE_DISK_IMAGE_EXTENSIONS = new Set([".d64", ".g64", ".d71", ".g71", ".d81", ".d80", ".d82", ".x64", ".p64", ".d1m", ".d2m", ".d4m"]);
+/**
+ * Bytes written to unused RAM ($02A7-$02AA) before an autoload. The autoload's
+ * power cycle clears them, which shows that the reset has happened.
+ */
+const AUTOLOAD_MARKER_ADDRESS = 0x02a7;
+const AUTOLOAD_MARKER = Buffer.from([0xc6, 0x4b, 0x1d, 0x9e]);
+/**
+ * Wait until VICE's autoload has reset the machine and its LOAD has finished.
+ * Completion is the LOAD"/READY. text on screen, or, when the loaded program
+ * covers screen RAM, BASIC initialised (TXTTAB $0801) with its end-of-program
+ * pointer (VARTAB) moved off the reset value $0803 and an empty keyboard buffer.
+ */
+async function waitForAutoloadFinished(client, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let loadedEnd = null;
+    while (Date.now() < deadline) {
+        await client.exitMonitor();
+        await delay(250);
+        const marker = await client.memGet(AUTOLOAD_MARKER_ADDRESS, AUTOLOAD_MARKER_ADDRESS + AUTOLOAD_MARKER.length - 1);
+        if (Buffer.from(marker).equals(AUTOLOAD_MARKER))
+            continue; // not reset yet
+        const screen = screenCodesToAscii(await client.memGet(0x0400, 0x0400 + 999));
+        const load = screen.lastIndexOf('LOAD"');
+        if (load >= 0) {
+            const after = screen.slice(load);
+            // An empty disk is still attached; it just has no program for the autoload to load.
+            if (/\?FILE NOT FOUND/.test(after))
+                return { loaded: false };
+            const error = /\?([A-Z ]+ERROR|DEVICE NOT PRESENT)/.exec(after);
+            if (error)
+                throw new Error(`VICE autoload failed: ?${error[1]}`);
+            if (after.includes("READY."))
+                return { loaded: true };
+        }
+        // TXTTAB = $0801 shows BASIC has initialised (right after the power cycle RAM
+        // holds VICE's init pattern); VARTAB off $0803 then shows the LOAD has ended.
+        const pointers = await client.memGet(0x002b, 0x002e);
+        const keyboardQueue = await client.memGet(0x00c6, 0x00c6);
+        const txttab = (pointers[0] ?? 0) | ((pointers[1] ?? 0) << 8);
+        const vartab = (pointers[2] ?? 0) | ((pointers[3] ?? 0) << 8);
+        // BASIC's cold start sets TXTTAB before VARTAB, so require the same end
+        // pointer on two consecutive polls before trusting it.
+        const candidate = txttab === 0x0801 && vartab !== 0x0803 && keyboardQueue[0] === 0 ? vartab : null;
+        if (candidate !== null && candidate === loadedEnd)
+            return { loaded: true };
+        loadedEnd = candidate;
+    }
+    throw new Error("VICE autoload did not finish within the time limit");
+}
 /** C64U drive letters with their factory bus numbers, so one drive id works on both backends. */
 const VICE_DRIVE_LETTERS = { a: 8, b: 9 };
 function parseDriveNumber(drive) {

package/dist/diagnostics.js

@@ -137,8 +137,16 @@ export function readDiagnosticRecords(filePath) {
     if (!text) {
         return [];
     }
-    return text.split("\n")
-        .map((line) => JSON.parse(line));
+    // The file is appended while the server runs, so a crash or a concurrent
+    // read can leave a partial last line; skip lines that are not whole records.
+    return text.split("\n").flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
 }
 export function summarizeDiagnosticsSession(filePath, options = {}) {
     const records = readDiagnosticRecords(filePath);

package/dist/mcp-server.js

@@ -449,7 +449,7 @@ async function main() {
         writeDiagnosticEvent("mcp_transport_connected", { mode: "stdio" });
         console.error("c64bridge MCP server running on stdio");
     }
-    await logConnectivity(client, baseUrl);
+    await logConnectivity(client, baseUrl, config.networkPassword);
     writeDiagnosticEvent("server_ready", {
         diagnosticsFile: diagnostics.filePath,
     });
@@ -524,7 +524,11 @@ export async function renderPlatformStatusMarkdown(client) {
     lines.push("> Use `c64_select_backend` to switch to another available backend without restarting the MCP server.");
     return lines.join("\n");
 }
-async function logConnectivity(client, baseUrl) {
+/** URL of the Ultimate's /v1/info route, keeping any path prefix of the base URL (reverse proxy). */
+export function connectivityProbeUrl(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/v1/info`;
+}
+async function logConnectivity(client, baseUrl, networkPassword) {
     const backendType = await client.getBackendType();
     if (backendType === "vice") {
         writeDiagnosticEvent("connectivity_probe_skipped", { baseUrl, reason: "vice_backend" });
@@ -550,10 +554,14 @@ async function logConnectivity(client, baseUrl) {
     }
     const c64Logger = loggerFor("c64u");
     const startedAt = Date.now();
-    const infoUrl = new URL("/v1/info", baseUrl).toString();
+    const infoUrl = connectivityProbeUrl(baseUrl);
     let response = null;
     try {
-        const probeResponse = await axios.get(infoUrl, { timeout: 2000 });
+        // Send the network password like every other request, or a protected device answers 403.
+        const probeResponse = await axios.get(infoUrl, {
+            timeout: 2000,
+            ...(networkPassword ? { headers: { "X-Password": networkPassword } } : {}),
+        });
         response = probeResponse;
         const latency = Date.now() - startedAt;
         const bytes = payloadByteLength(probeResponse.data);