c64bridge 1.0.5 → 1.0.6

package/dist/tools/programRunners.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { assemblyToPrgDetailed, AssemblyError, prgEntryAddress } from "./translation/assembler.js";
+import { assemblyToPrgDetailed, AssemblyError } from "./translation/assembler.js";
 import { basicToPrg } from "./translation/basicTokenizer.js";
 import { defineToolModule, OPERATION_DISCRIMINATOR, } from "./types.js";
 import { booleanSchema, objectSchema, optionalSchema, stringSchema } from "./schema.js";
@@ -267,7 +267,7 @@ async function executeUploadRunBasic(rawArgs, ctx) {
         const runBasic = async (source) => ctx.client.uploadAndRunBasic(source);
         let result = await runBasic(activeProgram);
         if (!result.success) {
-            throw new ToolExecutionError("C64 firmware reported failure while running BASIC program", {
+            throw new ToolExecutionError("C64 backend reported failure while running BASIC program", {
                 details: extractFailureDetails(result.details),
             });
         }
@@ -442,13 +442,13 @@ async function executeUploadRunAsm(rawArgs, ctx) {
         // Assemble locally to expose structured metadata and capture symbols
         const asmResult = assemblyToPrgDetailed(parsed.program);
         const prg = asmResult.prg;
-        const entryAddress = prgEntryAddress(prg);
+        const entryAddress = asmResult.entryAddress;
         if (ctx.platform.id === "vice") {
             setViceSymbols(asmResult.symbols.entries());
         }
         const result = await ctx.client.uploadAndRunAsm(parsed.program);
         if (!result.success) {
-            return toolErrorResult(new ToolExecutionError("C64 firmware reported failure while running assembly program", {
+            return toolErrorResult(new ToolExecutionError("C64 backend reported failure while running assembly program", {
                 details: extractFailureDetails(result.details),
             }));
         }
@@ -516,7 +516,7 @@ async function executeLoadPrg(rawArgs, ctx) {
         ctx.logger.info("Loading PRG file", { path: parsed.path });
         const result = await ctx.client.loadPrgFile(parsed.path);
         if (!result.success) {
-            throw new ToolExecutionError("C64 firmware reported failure while loading PRG", {
+            throw new ToolExecutionError("C64 backend reported failure while loading PRG", {
                 details: extractFailureDetails(result.details),
             });
         }
@@ -566,7 +566,7 @@ async function executeRunPrg(rawArgs, ctx) {
         }
         const result = await ctx.client.runPrgFile(parsed.path);
         if (!result.success) {
-            throw new ToolExecutionError("C64 firmware reported failure while running PRG", {
+            throw new ToolExecutionError("C64 backend reported failure while running PRG", {
                 details: extractFailureDetails(result.details),
             });
         }
@@ -601,7 +601,7 @@ async function executeRunCrt(rawArgs, ctx) {
         ctx.logger.info("Running CRT file", { path: parsed.path });
         const result = await ctx.client.runCrtFile(parsed.path);
         if (!result.success) {
-            throw new ToolExecutionError("C64 firmware reported failure while running CRT", {
+            throw new ToolExecutionError("C64 backend reported failure while running CRT", {
                 details: extractFailureDetails(result.details),
             });
         }
@@ -773,7 +773,7 @@ export const programRunnersModule = defineToolModule({
                     ctx.logger.info("Running CRT file", { path: parsed.path });
                     const result = await ctx.client.runCrtFile(parsed.path);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while running CRT", {
+                        throw new ToolExecutionError("C64 backend reported failure while running CRT", {
                             details: extractFailureDetails(result.details),
                         });
                     }

package/dist/tools/registry/disk.js

@@ -76,7 +76,7 @@ const createImageArgsSchema = objectSchema({
             maxLength: 16,
         })),
         tracks: optionalSchema(numberSchema({
-            description: "Track count (D64 supports 35 or 40; DNP requires explicit tracks).",
+            description: "Track count (D64 supports 35 to 41; DNP requires explicit tracks).",
             integer: true,
             minimum: 1,
             maximum: 255,
@@ -210,10 +210,10 @@ const diskOperations = [
             const { path, diskname, tracks } = parsed;
             switch (format) {
                 case "d64":
-                    if (tracks !== undefined && tracks !== 35 && tracks !== 40) {
-                        throw new ToolValidationError("D64 images support 35 or 40 tracks", {
+                    if (tracks !== undefined && (tracks < 35 || tracks > 41)) {
+                        throw new ToolValidationError("D64 images support 35 to 41 tracks", {
                             path: "$.tracks",
-                            details: { allowed: [35, 40], received: tracks },
+                            details: { minimum: 35, maximum: 41, received: tracks },
                         });
                     }
                     return storageModule.invoke("create_d64", { path, tracks, diskname }, ctx);
@@ -274,8 +274,10 @@ export const diskModuleGroup = defineToolModule({
                 variants: diskOperations.map((operation) => operation.schema),
             }),
             tags: ["storage", "drive", "grouped"],
-            operationPlatforms: { file_info: ["c64u", "u2"], create_image: ["c64u", "u2"], find_and_run: ["c64u", "u2"] },
+            // The VICE Binary Monitor has no command to detach a disk image, so unmount is Ultimate-only.
+            operationPlatforms: { unmount: ["c64u", "u2"], file_info: ["c64u", "u2"], create_image: ["c64u", "u2"], find_and_run: ["c64u", "u2"] },
             operationToolNames: {
+                unmount: "drive_remove",
                 file_info: "file_info",
                 create_image: "create_image",
                 find_and_run: "find_and_run_program_by_name",

package/dist/tools/storage.js

@@ -97,10 +97,10 @@ const createD64ArgsSchema = objectSchema({
     properties: {
         path: diskImagePathSchema,
         tracks: optionalSchema(numberSchema({
-            description: "Track count (35 for standard, 40 for extended).",
+            description: "Track count: 35 for a standard disk, up to 41 for the extended area (firmware limit).",
             integer: true,
             minimum: 35,
-            maximum: 40,
+            maximum: 41,
         })),
         diskname: diskNameSchema,
     },
@@ -175,7 +175,7 @@ export const storageModule = defineToolModule({
                     drivesListArgsSchema.parse(args ?? {});
                     ctx.logger.info("Listing Ultimate drives");
                     const details = await ctx.client.drivesList();
-                    return textResult("Retrieved Ultimate drive status.", {
+                    return textResult("Retrieved drive status.", {
                         success: true,
                         drives: details,
                     });
@@ -221,14 +221,16 @@ export const storageModule = defineToolModule({
                         mode: parsed.mode,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while mounting disk image", {
+                        throw new ToolExecutionError("C64 backend reported failure while mounting disk image", {
                             details: normaliseFailure(result.details),
                         });
                     }
                     const details = toRecord(result.details) ?? {};
                     const finalMode = typeof details.mode === "string" ? details.mode : parsed.mode ?? null;
                     const finalType = typeof details.type === "string" ? details.type : parsed.type ?? null;
-                    return textResult(`Mounted ${parsed.image} on ${parsed.drive}.`, {
+                    // Backend notes (for example VICE's autoload resetting the machine) belong in the visible text.
+                    const note = typeof details.note === "string" ? ` ${details.note}` : "";
+                    return textResult(`Mounted ${parsed.image} on ${parsed.drive}.${note}`, {
                         success: true,
                         drive: parsed.drive,
                         image: parsed.image,
@@ -269,7 +271,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Removing disk image", { drive: parsed.drive });
                     const result = await ctx.client.driveRemove(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while removing disk image", {
+                        throw new ToolExecutionError("C64 backend reported failure while removing disk image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -311,7 +313,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Resetting drive", { drive: parsed.drive });
                     const result = await ctx.client.driveReset(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while resetting drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while resetting drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -353,7 +355,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Powering on drive", { drive: parsed.drive });
                     const result = await ctx.client.driveOn(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while powering on drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while powering on drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -396,7 +398,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Powering off drive", { drive: parsed.drive });
                     const result = await ctx.client.driveOff(parsed.drive);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while powering off drive", {
+                        throw new ToolExecutionError("C64 backend reported failure while powering off drive", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -439,7 +441,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Loading drive ROM", { drive: parsed.drive, path: parsed.path });
                     const result = await ctx.client.driveLoadRom(parsed.drive, parsed.path);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while loading drive ROM", {
+                        throw new ToolExecutionError("C64 backend reported failure while loading drive ROM", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -482,7 +484,7 @@ export const storageModule = defineToolModule({
                     ctx.logger.info("Setting drive mode", { drive: parsed.drive, mode: parsed.mode });
                     const result = await ctx.client.driveSetMode(parsed.drive, parsed.mode);
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while setting drive mode", {
+                        throw new ToolExecutionError("C64 backend reported failure while setting drive mode", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -541,7 +543,7 @@ export const storageModule = defineToolModule({
         {
             name: "create_d64",
             description: "Create a blank D64 disk image on the Ultimate filesystem.",
-            summary: "Allocates a 35 or 40 track D64 image with an optional disk name.",
+            summary: "Allocates a 35 to 41 track D64 image with an optional disk name.",
             inputSchema: createD64ArgsSchema.jsonSchema,
             relatedResources: ["c64://guide/bootstrap"],
             tags: ["disk", "create"],
@@ -569,14 +571,16 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D64 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D64 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
+                    const firmwareTracks = toRecord(result.details)?.tracks;
                     return textResult(`Created D64 image at ${parsed.path}.`, {
                         success: true,
                         path: parsed.path,
-                        tracks: parsed.tracks ?? null,
+                        // The firmware reports the track count it used, including its default of 35.
+                        tracks: typeof firmwareTracks === "number" ? firmwareTracks : parsed.tracks ?? 35,
                         diskname: parsed.diskname ?? null,
                         details: toRecord(result.details) ?? {},
                     });
@@ -618,7 +622,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D71 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D71 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -666,7 +670,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating D81 image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating D81 image", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -717,7 +721,7 @@ export const storageModule = defineToolModule({
                         diskname: parsed.diskname,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while creating DNP image", {
+                        throw new ToolExecutionError("C64 backend reported failure while creating DNP image", {
                             details: normaliseFailure(result.details),
                         });
                     }

package/dist/tools/streaming.js

@@ -80,7 +80,7 @@ export const streamingModule = defineToolModule({
                     });
                     const result = await ctx.client.streamStart(parsed.stream, parsed.target);
                     if (!result.success) {
-                        throw new ToolExecutionError(withFailureReason("C64 firmware reported failure while starting stream", result.details), {
+                        throw new ToolExecutionError(withFailureReason("C64 backend reported failure while starting stream", result.details), {
                             details: toRecord(result.details),
                         });
                     }
@@ -120,7 +120,7 @@ export const streamingModule = defineToolModule({
                     });
                     const result = await ctx.client.streamStop(parsed.stream);
                     if (!result.success) {
-                        throw new ToolExecutionError(withFailureReason("C64 firmware reported failure while stopping stream", result.details), {
+                        throw new ToolExecutionError(withFailureReason("C64 backend reported failure while stopping stream", result.details), {
                             details: toRecord(result.details),
                         });
                     }

package/dist/tools/translation/assembler.js

@@ -126,7 +126,13 @@ export function assemblyToPrgDetailed(source, options) {
     const assembler = new Assembler(statements, loadAddress);
     assembler.runPass(0);
     assembler.runPass(1);
-    return { prg: assembler.buildPrg(), symbols: assembler.getSymbols() };
+    const prg = assembler.buildPrg();
+    const loadAddressOfPrg = prg.length >= 2 ? prg.readUInt16LE(0) : loadAddress;
+    const stubTarget = prg.length >= 2 ? prgEntryAddress(prg) : loadAddressOfPrg;
+    const entryAddress = stubTarget !== loadAddressOfPrg
+        ? stubTarget
+        : assembler.getFirstInstructionAddress() ?? loadAddressOfPrg;
+    return { prg, symbols: assembler.getSymbols(), entryAddress };
 }
 function normalizeSource(input) {
     return input.replace(/\r\n?/g, "\n");
@@ -510,8 +516,14 @@ function parseUnaryExpression(stream, terminators) {
     }
     // In operand position, "<" and ">" are byte selectors and "*" is the current
     // PC; parseBinaryExpression consumes them as binary operators elsewhere.
+    // As in ACME, 64tass, DASM and Kick Assembler, "<" and ">" apply to the
+    // whole rest of the expression: "#>msg+1" is the high byte of msg+1.
+    if (token.kind === "punct" && (token.value === "<" || token.value === ">")) {
+        const operand = parseBinaryExpression(stream, terminators, 0);
+        return { type: "unary", op: token.value, operand };
+    }
     if (token.kind === "punct" &&
-        (token.value === "+" || token.value === "-" || token.value === "!" || token.value === "~" || token.value === "<" || token.value === ">")) {
+        (token.value === "+" || token.value === "-" || token.value === "!" || token.value === "~")) {
         const operand = parseUnaryExpression(stream, terminators);
         return { type: "unary", op: token.value, operand };
     }
@@ -708,6 +720,8 @@ class Assembler {
         this.pc = 0;
         this.lowestWritten = MAX_ADDRESS;
         this.highestWritten = 0;
+        /** Reserved (.res) ranges from the last pass, as [start, end] inclusive. */
+        this.reserved = [];
         this.symbolTable.reset();
     }
     runPass(pass) {
@@ -719,6 +733,7 @@ class Assembler {
             this.highestWritten = 0;
             this.firstInstructionAddress = undefined;
         }
+        this.reserved = [];
         // Loading a PRG at $0801 makes BASIC relink the bytes there as program
         // lines, which corrupts raw machine code. Code that starts at $0801
         // without its own org therefore gets a "10 SYS" stub that jumps to the
@@ -766,13 +781,33 @@ class Assembler {
         if (this.lowestWritten > this.highestWritten) {
             return Buffer.alloc(0);
         }
-        const start = this.lowestWritten;
-        const end = this.highestWritten;
+        let start = this.lowestWritten;
+        let end = this.highestWritten;
+        // Reserved space that adjoins the emitted bytes (a trailing "counter: .res 1")
+        // is part of the image and zero-filled, as in ca65 and DASM; detached blocks
+        // such as zero-page variables are not, so they do not stretch the PRG.
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const [resStart, resEnd] of this.reserved) {
+                // Adjoining or overlapping blocks extend the image.
+                if (resStart <= end + 1 && resEnd > end) {
+                    end = resEnd;
+                    changed = true;
+                }
+                if (resEnd >= start - 1 && resStart < start) {
+                    start = resStart;
+                    changed = true;
+                }
+            }
+        }
         const body = this.memory.subarray(start, end + 1);
         const header = Buffer.alloc(2);
         header.writeUInt16LE(start, 0);
         return Buffer.concat([header, Buffer.from(body)]);
     }
+    getFirstInstructionAddress() {
+        return this.firstInstructionAddress;
+    }
     getSymbols() {
         return this.symbolTable.allGlobals();
     }
@@ -898,14 +933,11 @@ class Assembler {
                 if (amount < 0) {
                     throw new AssemblyError("reserve directive requires a non-negative size", location);
                 }
-                if (pass === 1) {
-                    for (let i = 0; i < amount; i += 1) {
-                        this.writeByte(0, location);
-                    }
-                }
-                else {
-                    this.pc += amount;
-                }
+                // Reserved space advances the PC without emitting; buildPrg includes it
+                // (zero-filled) only where it adjoins emitted bytes.
+                if (amount > 0)
+                    this.reserved.push([this.pc, Math.min(0xffff, this.pc + amount - 1)]);
+                this.pc = (this.pc + amount) & 0xffff;
                 break;
             }
             case "include": {

package/dist/tools/translation/basicTokenizer.js

@@ -116,7 +116,11 @@ function tokenize(content) {
             }
             continue;
         }
-        const plainChar = (!inString && !inRemark ? upper[index] : char) ?? char;
+        // REM text folds only ASCII a-z, like string text (LIST would show them as
+        // graphics); full Unicode upper-casing could change length or leave Latin-1.
+        const plainChar = inRemark
+            ? (char >= "a" && char <= "z" ? char.toUpperCase() : char)
+            : (!inString ? upper[index] : char) ?? char;
         bytes.push(asciiToPetscii(plainChar));
         if (inData && !inString && plainChar === ":") {
             inData = false;

package/dist/tools/translation/opcodeInventory.js

@@ -55,7 +55,7 @@ const OPCODE_ROWS = [
     // 0xE0-0xEF
     [["CPX", M.Imm], ["SBC", M.IndX], ["NOP", M.Imm], ["INS", M.IndX], ["CPX", M.Zp], ["SBC", M.Zp], ["INC", M.Zp], ["INS", M.Zp], ["INX", M.Imp], ["SBC", M.Imm], ["NOP", M.Imp], ["SBC", M.Imm], ["CPX", M.Abs], ["SBC", M.Abs], ["INC", M.Abs], ["INS", M.Abs]],
     // 0xF0-0xFF
-    [["BEQ", M.Rel], ["SBC", M.IndY], ["HLT", M.Imp], ["INS", M.IndY], ["NOP", M.ZpS], ["SBC", M.ZpX], ["INC", M.ZpX], ["INS", M.ZpX], ["SED", M.Imp], ["SBC", M.AbsY], ["NOP", M.Imp], ["INS", M.AbsY], ["NOP", M.AbsX], ["SBC", M.AbsX], ["INC", M.AbsX], ["INS", M.AbsX]],
+    [["BEQ", M.Rel], ["SBC", M.IndY], ["HLT", M.Imp], ["INS", M.IndY], ["NOP", M.ZpX], ["SBC", M.ZpX], ["INC", M.ZpX], ["INS", M.ZpX], ["SED", M.Imp], ["SBC", M.AbsY], ["NOP", M.Imp], ["INS", M.AbsY], ["NOP", M.AbsX], ["SBC", M.AbsX], ["INC", M.AbsX], ["INS", M.AbsX]],
 ];
 const ILLEGAL_MAP = [
     0x989C, 0x9C9C, 0x888C, 0x9C9C,

package/dist/tools/vice.js

@@ -33,7 +33,7 @@ const resourceValueSchema = {
     },
 };
 const resourceNameSchema = stringSchema({
-    description: "VICE resource name (example: SidEngine, C64Model).",
+    description: "VICE resource name (example: SidEngine, SidModel).",
     minLength: 1,
     maxLength: 64,
     pattern: RESOURCE_NAME_PATTERN,

package/dist/vice/mockServer.js

@@ -40,10 +40,16 @@ export class ViceMockServer {
         this.registerMetadata = buildDefaultRegisterMetadata();
         this.registerValues = new Map();
         this.resources = new Map();
+        /** Output lines of VICE's I/O simulation joyport device per port (0 = port 1). */
+        this.joyportOutput = [0, 0];
         this.sockets = new Set();
+        /** Images attached with autostart, and drive CPU resets, as observed by tests. */
+        this.autostarts = [];
+        this.driveResets = [];
         this.host = options?.host ?? "127.0.0.1";
         this.requestedPort = options?.port;
         this.resetState();
+        this.resetResources();
     }
     async start() {
         if (this.server)
@@ -114,9 +120,26 @@ export class ViceMockServer {
         switch (cmd) {
             case 0x85: // info
                 return buildResponse(cmd, reqId);
-            case 0xCC: // reset
-                this.resetState();
+            case 0xCC: { // reset: types 8-11 reset only that drive's CPU
+                const type = body[0] ?? 0;
+                if (type >= 8 && type <= 11) {
+                    this.driveResets.push(type);
+                }
+                else {
+                    this.resetState();
+                }
+                return buildResponse(cmd, reqId);
+            }
+            case 0xDD: { // autostart: power-cycles, attaches the image to drive 8 and loads (run=1 also runs)
+                const nameLength = body[3] ?? 0;
+                this.autostarts.push({
+                    run: body[0] === 1,
+                    fileIndex: body.readUInt16LE(1),
+                    filename: body.subarray(4, 4 + nameLength).toString("utf8"),
+                });
+                this.renderAutoload(body[0] === 1);
                 return buildResponse(cmd, reqId);
+            }
             case 0x11: { // checkpoint get
                 const id = body.readUInt32LE(0);
                 const checkpoint = this.checkpoints.get(id);
@@ -185,13 +208,17 @@ export class ViceMockServer {
             case 0x01: { // mem get
                 const start = body.readUInt16LE(1);
                 const end = body.readUInt16LE(3);
-                const length = Math.max(0, end - start + 1);
+                if (start > end) {
+                    return buildResponse(cmd, reqId, Buffer.alloc(0), 0x81); // VICE rejects start > end with INVALID_PARAMETER.
+                }
+                const length = end - start + 1;
                 const payload = Buffer.alloc(2 + length);
                 payload.writeUInt16LE(length & 0xffff, 0); // Like VICE: a full 64 KB read reports ML = 0.
                 for (let i = 0; i < length; i += 1) {
                     payload[2 + i] = this.memory[(start + i) & 0xffff];
                 }
                 this.applyHeartbeatOverlay(start, length, payload);
+                this.applyJoyportOverlay(start, length, payload);
                 return buildResponse(cmd, reqId, payload);
             }
             case 0x02: { // mem set
@@ -246,7 +273,7 @@ export class ViceMockServer {
                 const name = body.subarray(1, 1 + nameLen).toString("utf8");
                 const value = this.resources.get(name);
                 if (value === undefined) {
-                    return buildResponse(cmd, reqId, Buffer.from([0, 0]));
+                    return buildResponse(cmd, reqId, Buffer.alloc(0), 0x01); // VICE: OBJECT_MISSING for an unknown resource.
                 }
                 if (typeof value === "number") {
                     const buffer = Buffer.alloc(2 + 4);
@@ -266,12 +293,20 @@ export class ViceMockServer {
                 const isNumber = body[0] === 1;
                 const nameLen = body[1] ?? 0;
                 const name = body.subarray(2, 2 + nameLen).toString("utf8");
+                if (!this.resources.has(name)) {
+                    // VICE: an unknown integer resource fails resources_set (CMD_FAILURE); an unknown string one is OBJECT_MISSING.
+                    return buildResponse(cmd, reqId, Buffer.alloc(0), isNumber ? 0x8f : 0x01);
+                }
                 if (isNumber) {
                     const valueLen = body[2 + nameLen] ?? 0;
                     const valueBytes = body.subarray(3 + nameLen, 3 + nameLen + valueLen);
                     const padded = Buffer.alloc(4);
                     valueBytes.copy(padded, 0, 0, Math.min(4, valueBytes.length));
                     const value = padded.readInt32LE(0);
+                    // VICE rejects joyport device ids it does not have (JOYPORT_MAX_DEVICES is 44 in 3.10).
+                    if (/^JoyPort\dDevice$/.test(name) && (value < 0 || value >= 44)) {
+                        return buildResponse(cmd, reqId, Buffer.alloc(0), 0x8f);
+                    }
                     this.resources.set(name, value);
                 }
                 else {
@@ -281,6 +316,18 @@ export class ViceMockServer {
                 }
                 return buildResponse(cmd, reqId);
             }
+            case 0xA2: { // joyport set: like VICE, it only stores the I/O simulation device's output lines
+                const port = body.readUInt16LE(0);
+                const value = body.readUInt16LE(2);
+                if (port > 1) {
+                    return buildResponse(cmd, reqId, Buffer.alloc(0), 0x01);
+                }
+                if (value > 0xff) {
+                    return buildResponse(cmd, reqId, Buffer.alloc(0), 0x81);
+                }
+                this.joyportOutput[port] = value & 0x1f;
+                return buildResponse(cmd, reqId);
+            }
             case 0xAA: // exit monitor
                 return buildResponse(cmd, reqId);
             case 0xBB: // quit
@@ -434,11 +481,51 @@ export class ViceMockServer {
         for (const meta of this.registerMetadata) {
             this.registerValues.set(meta.id, 0);
         }
+        this.joyportOutput = [0, 0];
+    }
+    // Resources survive a machine reset in VICE. Only resources that exist in
+    // VICE 3.10 are known; others fail the way VICE fails (see below).
+    resetResources() {
         this.resources = new Map([
-            ["C64Model", 2],
             ["SidEngine", 1],
+            ["JoyPort1Device", 1],
+            ["JoyPort2Device", 1],
+            ["Drive8Type", 1541],
+            ["Drive9Type", 0],
+            ["Drive10Type", 0],
+            ["Drive11Type", 0],
+            ["VICIIDoubleSize", 0],
+            ["VICIIBorderMode", 0],
+            ["VICIIFullscreen", 0],
+            ["SoundVolume", 100],
+            ["SidModel", 0],
+            ["MachineVideoStandard", 1],
+            ["KernalName", "kernal-901227-03.bin"],
         ]);
     }
+    /** Lines a joyport device drives, as CIA1 sees them (active low); only the I/O simulation device (37) is modelled. */
+    joyportLines(port) {
+        return this.resources.get(`JoyPort${port}Device`) === 37 ? this.joyportOutput[port - 1] : 0xff;
+    }
+    // CIA1 port A ($DC00) reads joyport 2 and port B ($DC01) joyport 1, ANDed with the keyboard lines.
+    applyJoyportOverlay(start, length, payload) {
+        for (const [address, port] of [[0xdc00, 2], [0xdc01, 1]]) {
+            if (address >= start && address < start + length) {
+                payload[2 + address - start] = 0xff & this.joyportLines(port);
+            }
+        }
+    }
+    // What VICE's autoload leaves on screen after its power cycle: the typed LOAD and READY.
+    renderAutoload(run) {
+        // The power cycle's KERNAL reset clears $0200-$03FF (RAMTAS).
+        this.memory.fill(0x00, 0x0200, 0x0400);
+        this.memory.fill(0x20, SCREEN_BASE, SCREEN_BASE + 1000);
+        const lines = ['LOAD"*",8,1', "", "SEARCHING FOR *", "LOADING", "READY.", ...(run ? ["RUN"] : [])];
+        lines.forEach((line, row) => {
+            const codes = asciiToScreenCodes(line);
+            codes.copy(Buffer.from(this.memory.buffer, SCREEN_BASE + row * 40, codes.length));
+        });
+    }
     renderHello() {
         if (this.helloReady)
             return;

package/dist/vice/readiness.js

@@ -126,15 +126,10 @@ export function asciiToScreenCodes(text) {
             out.push(ch.charCodeAt(0) - 64);
         else if (ch >= '0' && ch <= '9')
             out.push(0x30 + (ch.charCodeAt(0) - 48));
-        else if (ch === ' ')
-            out.push(0x20);
-        else if (ch === '.')
-            out.push(0x2E);
-        else if (ch === ':')
-            out.push(0x3A);
-        else if (ch === '-')
-            out.push(0x2D);
-        // extend as needed; ignore others
+        // Space, digits and punctuation ($20-$3F) have the same screen codes as ASCII.
+        else if (ch >= ' ' && ch <= '?')
+            out.push(ch.charCodeAt(0));
+        // ignore others
     }
     return Buffer.from(out);
 }

package/dist/vice/viceClient.js

@@ -159,6 +159,24 @@ export class ViceClient {
     async resetSoft() { await this.send(0xCC, Buffer.from([0x00])); }
     async resetHard() { await this.send(0xCC, Buffer.from([0x01])); }
     async reset(type = 0) { await this.send(0xCC, Buffer.from([type])); }
+    /** Reset only the drive CPU of unit 8-11 (BM 0xCC reset types 8-11). */
+    async resetDrive(unit) { await this.send(0xCC, Buffer.from([unit])); }
+    /**
+     * Attach an image and load from it (BM 0xDD Autostart). With run=false VICE
+     * uses its autoload mode, which attaches to drive 8 and LOADs without RUN.
+     */
+    async autostart(filename, options) {
+        const name = Buffer.from(filename, "utf8");
+        if (name.length === 0 || name.length > 255) {
+            throw new Error("Autostart file names must be 1-255 bytes");
+        }
+        const body = Buffer.alloc(4 + name.length);
+        body[0] = options.run ? 1 : 0;
+        body.writeUInt16LE(options.fileIndex ?? 0, 1);
+        body[3] = name.length;
+        name.copy(body, 4);
+        await this.send(0xDD, body);
+    }
     /**
      * Exit the emulator process (BM 0xBB Quit). The socket will be closed by VICE.
      * Consumers should still call close() to dispose any local resources.

package/mcp/schemas/c64_disk.schema.json

@@ -119,7 +119,7 @@
         "integer",
         "null"
       ],
-      "description": "Track count (D64 supports 35 or 40; DNP requires explicit tracks).",
+      "description": "Track count (D64 supports 35 to 41; DNP requires explicit tracks).",
       "minimum": 1,
       "maximum": 255
     },
@@ -421,7 +421,7 @@
               "integer",
               "null"
             ],
-            "description": "Track count (D64 supports 35 or 40; DNP requires explicit tracks).",
+            "description": "Track count (D64 supports 35 to 41; DNP requires explicit tracks).",
             "minimum": 1,
             "maximum": 255
           },