c64bridge 1.0.5 → 1.0.7

package/dist/tools/meta/configInventory.js

@@ -1,3 +1,4 @@
+import { isSensitiveConfigItem, redactConfigValue, REDACTED_PLACEHOLDER } from "../../redact.js";
 export function normalizeConfigInventory(details) {
     const categories = details?.categories;
     if (!Array.isArray(categories)) {
@@ -55,12 +56,15 @@ export function normalizeConfigInventory(details) {
     }
     return inventory;
 }
-export async function captureConfigSnapshot(client) {
+export async function captureConfigSnapshot(client, options = {}) {
     const inventory = normalizeConfigInventory(await client.configsList());
     const categories = {};
     for (const entry of inventory) {
         try {
-            const value = normalizeSnapshotValue(await client.configGet(entry.category, entry.item), entry);
+            const normalized = normalizeSnapshotValue(await client.configGet(entry.category, entry.item), entry);
+            const value = options.includeSecretValues
+                ? normalized
+                : redactConfigValue(normalized, entry.category, entry.item);
             setSnapshotValue(categories, entry, value);
         }
         catch (error) {
@@ -71,6 +75,25 @@ export async function captureConfigSnapshot(client) {
     }
     return { inventory, categories };
 }
+/**
+ * Drops redacted credential placeholders from a snapshot payload before it is
+ * written back, so restoring a default snapshot never sets a password to `***`.
+ */
+export function stripRedactedSecrets(categories) {
+    const strip = (category, value) => {
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            return value;
+        const kept = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (entry === REDACTED_PLACEHOLDER && isSensitiveConfigItem(category, key))
+                continue;
+            // Per-item snapshot entries keep the firmware wrapper: { category: { item: value } }.
+            kept[key] = strip(entry !== null && typeof entry === "object" && !Array.isArray(entry) ? key : category, entry);
+        }
+        return kept;
+    };
+    return Object.fromEntries(Object.entries(categories).map(([category, items]) => [category, strip(category, items)]));
+}
 export function validateSnapshotCategories(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Snapshot categories payload must be an object");

package/dist/tools/meta/diagnostics.js

@@ -74,7 +74,8 @@ export const tools = [
                     version,
                     info,
                 };
-                return jsonResult(report, { success: report.isHealthy });
+                const result = jsonResult(report, { success: report.isHealthy });
+                return report.isHealthy ? result : { ...result, isError: true };
             }
             catch (error) {
                 if (error instanceof ToolError)

package/dist/tools/meta/graphics.js

@@ -223,7 +223,7 @@ export const tools = [
                 try {
                     const read = await ctx.client.readMemory(`$${formatAddressHex(startAddress)}`, String(length));
                     if (!read.success || typeof read.data !== "string") {
-                        throw new ToolExecutionError("C64 firmware reported failure while reading memory", { details: normalizeErrorDetails(read.details) });
+                        throw new ToolExecutionError("C64 backend reported failure while reading memory", { details: normalizeErrorDetails(read.details) });
                     }
                     const bytes = hexToBytes(read.data);
                     if (bytes.length < length) {

package/dist/tools/meta/memory.js

@@ -97,7 +97,7 @@ export const tools = [
                 if (canPause) {
                     const pauseResult = await ctx.client.pause();
                     if (!pauseResult.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while pausing", { details: normalizeErrorDetails(pauseResult.details) });
+                        throw new ToolExecutionError("C64 backend reported failure while pausing", { details: normalizeErrorDetails(pauseResult.details) });
                     }
                     paused = true;
                 }
@@ -105,7 +105,7 @@ export const tools = [
                 try {
                     const pre = await ctx.client.readMemory(parsed.address, String(Math.max(1, readLen)));
                     if (!pre.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while reading memory", { details: normalizeErrorDetails(pre.details) });
+                        throw new ToolExecutionError("C64 backend reported failure while reading memory", { details: normalizeErrorDetails(pre.details) });
                     }
                     preReadHex = pre.data ?? "$";
                     const preBytes = hexToBytes(preReadHex);
@@ -125,11 +125,11 @@ export const tools = [
                     }
                     const write = await ctx.client.writeMemory(parsed.address, bytesToHex(writeBytes));
                     if (!write.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while writing memory", { details: normalizeErrorDetails(write.details) });
+                        throw new ToolExecutionError("C64 backend reported failure while writing memory", { details: normalizeErrorDetails(write.details) });
                     }
                     const post = await ctx.client.readMemory(parsed.address, String(Math.max(1, writeBytes.length)));
                     if (!post.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while reading back memory", { details: normalizeErrorDetails(post.details) });
+                        throw new ToolExecutionError("C64 backend reported failure while reading back memory", { details: normalizeErrorDetails(post.details) });
                     }
                     const postBytes = hexToBytes(post.data ?? "$");
                     const diffs = [];

package/dist/tools/meta/program.js

@@ -1,6 +1,7 @@
 import { objectSchema, stringSchema, arraySchema, numberSchema, optionalSchema, booleanSchema } from "../schema.js";
 import { jsonResult } from "../responses.js";
 import { ToolError, ToolUnsupportedPlatformError, ToolExecutionError, toolErrorResult, unknownErrorResult } from "../errors.js";
+import { measureSidSilence } from "../audio.js";
 import { getPlatformStatus } from "../../platform.js";
 import { promises as fs } from "node:fs";
 import { resolve as resolvePath, join as joinPath } from "node:path";
@@ -206,7 +207,7 @@ const batchRunWithAssertionsArgsSchema = objectSchema({
                 assertions: optionalSchema(arraySchema(objectSchema({
                     description: "Assertion to check after run",
                     properties: {
-                        type: stringSchema({ description: "Assertion type", enum: ["screen_contains", "memory_equals", "sid_silent"] }),
+                        type: stringSchema({ description: "Assertion type; sid_silent needs the C64 Ultimate audio stream (c64u backend).", enum: ["screen_contains", "memory_equals", "sid_silent"] }),
                         pattern: optionalSchema(stringSchema({ description: "Pattern for screen_contains", minLength: 1 })),
                         address: optionalSchema(stringSchema({ description: "Address for memory_equals", minLength: 1 })),
                         expected: optionalSchema(stringSchema({ description: "Expected value (hex)", minLength: 1 })),
@@ -720,17 +721,20 @@ export const tools = [
                                     status = "fail";
                             }
                             else if (assertion.type === "sid_silent") {
-                                // Check SID gate bits are off (simple check)
-                                const result = await ctx.client.readMemory("$D404", "1");
-                                if (!result.success || typeof result.data !== "string") {
-                                    throw new Error("Failed to read SID voice 1 control register for sid_silent assertion");
+                                // SID control registers are write-only (an Ultimate 64 reads $D404 as $00
+                                // whatever was written), so silence is measured from the Ultimate audio
+                                // stream. Other backends would fall back to the host microphone, which
+                                // measures the room rather than the C64, so they report an error instead.
+                                const backend = ctx.platform?.id ?? await ctx.client.getActiveBackendType?.();
+                                if (backend !== undefined && backend !== "c64u") {
+                                    throw new Error(`sid_silent needs the C64 Ultimate audio stream and is not available on ${backend}`);
                                 }
-                                const gate1 = parseInt(result.data.slice(1), 16) & 0x01;
-                                const isSilent = gate1 === 0;
+                                const silence = await measureSidSilence(ctx);
+                                const isSilent = silence.silent;
                                 assertionResults.push({
                                     type: assertion.type,
                                     status: isSilent ? "pass" : "fail",
-                                    message: isSilent ? undefined : "SID voice 1 gate is on",
+                                    message: isSilent ? undefined : `SID output is not silent (peak RMS ${silence.maxRms.toFixed(3)} > ${silence.threshold})`,
                                 });
                                 if (!isSilent)
                                     status = "fail";

package/dist/tools/printer.js

@@ -278,7 +278,7 @@ export const printerModule = defineToolModule({
                         formFeed: parsed.formFeed,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while printing text", {
+                        throw new ToolExecutionError("C64 backend reported failure while printing text", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -337,7 +337,7 @@ export const printerModule = defineToolModule({
                         ensureMsb: parsed.ensureMsb,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while printing Commodore bitmap", {
+                        throw new ToolExecutionError("C64 backend reported failure while printing Commodore bitmap", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -398,7 +398,7 @@ export const printerModule = defineToolModule({
                         timesPerLine: parsed.timesPerLine,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while printing Epson bitmap", {
+                        throw new ToolExecutionError("C64 backend reported failure while printing Epson bitmap", {
                             details: normaliseFailure(result.details),
                         });
                     }
@@ -458,7 +458,7 @@ export const printerModule = defineToolModule({
                         secondaryAddress: parsed.secondaryAddress,
                     });
                     if (!result.success) {
-                        throw new ToolExecutionError("C64 firmware reported failure while defining DLL characters", {
+                        throw new ToolExecutionError("C64 backend reported failure while defining DLL characters", {
                             details: normaliseFailure(result.details),
                         });
                     }

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/batch.js

@@ -2,7 +2,7 @@ import { defineToolModule, } from "../types.js";
 import { getPlatformStatus } from "../../platform.js";
 import { arraySchema, booleanSchema, objectSchema, optionalSchema, stringSchema, } from "../schema.js";
 import { jsonResult } from "../responses.js";
-import { ToolValidationError, unknownErrorResult } from "../errors.js";
+import { unknownErrorResult } from "../errors.js";
 const commandSchema = objectSchema({
     description: "A single batch command.",
     properties: {
@@ -155,12 +155,6 @@ export const batchModuleGroup = defineToolModule({
                     return jsonResult(summary, { success: failed === 0, succeeded, failed, total: parsed.commands.length });
                 }
                 catch (error) {
-                    if (error instanceof ToolValidationError) {
-                        return {
-                            content: [{ type: "text", text: error.message }],
-                            isError: true,
-                        };
-                    }
                     return unknownErrorResult(error);
                 }
             },

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,