c64bridge 0.9.0 → 0.9.2

package/dist/tools/registry/graphics.js

@@ -3,8 +3,8 @@ import { createOperationDispatcher, defineToolModule, discriminatedUnionSchema,
 import { graphicsModule, graphicsOperationHandlers as groupedGraphicsHandlers } from "../graphics.js";
 import { booleanSchema, literalSchema, numberSchema, objectSchema, optionalSchema, stringSchema, } from "../schema.js";
 import { buildDescriptorIndex, ensureDescriptor, extendSchemaWithOp, createOperationHandlers, } from "./utils.js";
-import { ToolError, toolErrorResult, unknownErrorResult, } from "../errors.js";
 import { jsonResult } from "../responses.js";
+import { ToolError, toolErrorResult, unknownErrorResult, } from "../errors.js";
 const graphicsDescriptorIndex = buildDescriptorIndex(graphicsModule);
 const captureFrameArgsSchema = objectSchema({
     description: "Capture one or more complete video frames from the active backend.",
@@ -30,6 +30,72 @@ const captureFrameArgsSchema = objectSchema({
     required: ["op"],
     additionalProperties: false,
 });
+// ---------------------------------------------------------------------------
+// get_display_state helpers — VIC-II register decoding
+// ---------------------------------------------------------------------------
+function parseVicState(d011, d016, d018, dd00, d020, d021) {
+    const bank = (~dd00) & 0x03; // CIA2 Port A bits 0-1 select VIC bank (inverted)
+    const bankBase = bank * 0x4000;
+    const bitmapMode = (d011 & 0x20) !== 0;
+    const extendedColor = (d011 & 0x40) !== 0;
+    const multicolor = (d016 & 0x10) !== 0;
+    const screenVisible = (d011 & 0x10) !== 0;
+    const raster8 = (d011 & 0x80) !== 0;
+    const vertScroll = d011 & 0x07;
+    const horizScroll = d016 & 0x07;
+    const columns40 = (d016 & 0x08) !== 0;
+    const rows25 = (d011 & 0x08) !== 0;
+    // D018 bits 4-7 = screen RAM offset (× $0400); bits 1-3 = char/bitmap pointer (× $0800)
+    const screenRamOffset = ((d018 >> 4) & 0x0f) * 0x0400;
+    const screenRamAddress = bankBase + screenRamOffset;
+    const charOrBitmapPointer = ((d018 >> 1) & 0x07) * 0x0800;
+    const charOrBitmapAddress = bankBase + charOrBitmapPointer;
+    let mode;
+    if (bitmapMode && multicolor)
+        mode = "multicolor_bitmap";
+    else if (bitmapMode)
+        mode = "hires_bitmap";
+    else if (extendedColor)
+        mode = "extended_color_text";
+    else if (multicolor)
+        mode = "multicolor_text";
+    else
+        mode = "standard_text";
+    return {
+        mode,
+        bank,
+        bankBase: `$${bankBase.toString(16).toUpperCase().padStart(4, "0")}`,
+        screenRamAddress: `$${screenRamAddress.toString(16).toUpperCase().padStart(4, "0")}`,
+        charOrBitmapAddress: `$${charOrBitmapAddress.toString(16).toUpperCase().padStart(4, "0")}`,
+        screenVisible,
+        bitmapMode,
+        extendedColor,
+        multicolor,
+        rows25,
+        columns40,
+        vertScroll,
+        horizScroll,
+        raster8,
+        borderColor: d020 & 0x0f,
+        backgroundColor: d021 & 0x0f,
+        registers: {
+            d011: `$${d011.toString(16).toUpperCase().padStart(2, "0")}`,
+            d016: `$${d016.toString(16).toUpperCase().padStart(2, "0")}`,
+            d018: `$${d018.toString(16).toUpperCase().padStart(2, "0")}`,
+            d020: `$${d020.toString(16).toUpperCase().padStart(2, "0")}`,
+            d021: `$${d021.toString(16).toUpperCase().padStart(2, "0")}`,
+            dd00: `$${dd00.toString(16).toUpperCase().padStart(2, "0")}`,
+        },
+    };
+}
+const getDisplayStateArgsSchema = objectSchema({
+    description: "Read VIC-II and CIA2 registers to determine the current graphics mode and memory layout. Works on C64U and VICE; both backends are read through shared memory primitives so the response shape is identical.",
+    properties: {
+        op: literalSchema("get_display_state"),
+    },
+    required: ["op"],
+    additionalProperties: false,
+});
 const graphicsOperations = [
     {
         op: "capture_frame",
@@ -105,6 +171,35 @@ const graphicsOperations = [
         schema: extendSchemaWithOp("render_bitmap", ensureDescriptor(graphicsDescriptorIndex, "render_bitmap").inputSchema, { description: "Import an image file, convert it to VIC-II bitmap memory, write it into RAM, and display it." }),
         handler: groupedGraphicsHandlers.render_bitmap,
     },
+    {
+        op: "get_display_state",
+        schema: getDisplayStateArgsSchema.jsonSchema,
+        handler: async (_rawArgs, ctx) => {
+            try {
+                // Use cross-platform memory reads so the same handler works on both
+                // C64U and VICE. The VIC-II and CIA2 registers live in machine memory
+                // either way; the underlying facade hides the transport difference.
+                const vicRegs = await ctx.client.readMemoryRaw(0xD011, 8);
+                const colorRegs = await ctx.client.readMemoryRaw(0xD020, 2);
+                const cia2 = await ctx.client.readMemoryRaw(0xDD00, 1);
+                const d011 = vicRegs[0] ?? 0;
+                const d016 = vicRegs[5] ?? 0; // $D016 = $D011 + 5
+                const d018 = vicRegs[7] ?? 0; // $D018 = $D011 + 7
+                const d020 = colorRegs[0] ?? 0;
+                const d021 = colorRegs[1] ?? 0;
+                const dd00 = cia2[0] ?? 0x03;
+                const backend = await ctx.client.getActiveBackendType();
+                const state = { ...parseVicState(d011, d016, d018, dd00, d020, d021), backend };
+                ctx.logger.info("Read VIC-II display state", { mode: state.mode, bank: state.bank, backend });
+                return jsonResult(state, { success: true, mode: state.mode, backend });
+            }
+            catch (error) {
+                if (error instanceof ToolError)
+                    return toolErrorResult(error);
+                return unknownErrorResult(error);
+            }
+        },
+    },
 ];
 const graphicsOperationHandlers = createOperationHandlers(graphicsOperations);
 export const graphicsModuleGroup = defineToolModule({
@@ -154,6 +249,11 @@ export const graphicsModuleGroup = defineToolModule({
                     description: "Convert a PNG into VIC bitmap memory and display it",
                     arguments: { op: "render_bitmap", imagePath: "./artifacts/sample.png", format: "hires" },
                 },
+                {
+                    name: "Read VIC-II state",
+                    description: "Decode graphics mode, memory layout, and colours from VIC-II registers (cross-platform)",
+                    arguments: { op: "get_display_state" },
+                },
             ],
             execute: createOperationDispatcher("c64_graphics", graphicsOperationHandlers),
         },

package/dist/tools/registry/index.js

@@ -14,6 +14,8 @@ import { extractModule } from "./extract.js";
 import { streamModule } from "./stream.js";
 import { debugModuleGroup as debugModule } from "../debug.js";
 import { viceModuleGroup as viceModule } from "../vice.js";
+import { inputModuleGroup as inputModule } from "./input.js";
+import { batchModuleGroup as batchModule } from "./batch.js";
 const modules = [
     programModule,
     memoryModule,
@@ -30,6 +32,8 @@ const modules = [
     streamModule,
     debugModule,
     viceModule,
+    inputModule,
+    batchModule,
 ];
 const toolMap = new Map();
 for (const module of modules) {

package/dist/tools/registry/input.js

@@ -0,0 +1,2 @@
+import { inputModule } from "../input.js";
+export { inputModule as inputModuleGroup };

package/dist/tools/registry/memory.js

@@ -1,5 +1,5 @@
 import { createOperationDispatcher, defineToolModule, discriminatedUnionSchema, } from "../types.js";
-import { memoryModule, memoryOperationHandlers as groupedMemoryHandlers } from "../memory.js";
+import { memoryModule, memoryOperationHandlers as groupedMemoryHandlers, disassembleArgsSchema, copyMemoryArgsSchema, fillMemoryArgsSchema, searchMemoryArgsSchema, compareMemoryArgsSchema, saveMemoryArgsSchema, } from "../memory.js";
 import { metaModule } from "../meta/index.js";
 import { buildDescriptorIndex, ensureDescriptor, extendSchemaWithOp, createOperationHandlers, invokeModuleTool, } from "./utils.js";
 const memoryDescriptorIndex = buildDescriptorIndex(memoryModule);
@@ -25,6 +25,36 @@ const memoryOperations = [
         schema: extendSchemaWithOp("wait_for_text", ensureDescriptor(metaDescriptorIndex, "wait_for_screen_text").inputSchema, { description: "Poll the screen until a substring or regex appears, or timeout elapses." }),
         handler: async (rawArgs, ctx) => invokeModuleTool(metaModule, "wait_for_screen_text", rawArgs, ctx),
     },
+    {
+        op: "disassemble",
+        schema: extendSchemaWithOp("disassemble", disassembleArgsSchema.jsonSchema, { description: "Disassemble a memory region into annotated 6502/6510 instructions, including undocumented opcodes with canonical names. Symbol annotations from `.vs` files are applied when available. Works on both C64U and VICE." }),
+        handler: groupedMemoryHandlers.disassemble,
+    },
+    {
+        op: "copy_memory",
+        schema: extendSchemaWithOp("copy_memory", copyMemoryArgsSchema.jsonSchema, { description: "Copy a RAM region to another address." }),
+        handler: groupedMemoryHandlers.copy_memory,
+    },
+    {
+        op: "fill_memory",
+        schema: extendSchemaWithOp("fill_memory", fillMemoryArgsSchema.jsonSchema, { description: "Fill a memory range with a repeating byte pattern." }),
+        handler: groupedMemoryHandlers.fill_memory,
+    },
+    {
+        op: "search_memory",
+        schema: extendSchemaWithOp("search_memory", searchMemoryArgsSchema.jsonSchema, { description: "Search for a byte pattern within a memory range and return matching addresses." }),
+        handler: groupedMemoryHandlers.search_memory,
+    },
+    {
+        op: "compare_memory",
+        schema: extendSchemaWithOp("compare_memory", compareMemoryArgsSchema.jsonSchema, { description: "Compare two memory regions byte-by-byte and report differences." }),
+        handler: groupedMemoryHandlers.compare_memory,
+    },
+    {
+        op: "save_memory",
+        schema: extendSchemaWithOp("save_memory", saveMemoryArgsSchema.jsonSchema, { description: "Dump a memory range to a local file, with an optional PRG load-address header." }),
+        handler: groupedMemoryHandlers.save_memory,
+    },
 ];
 const memoryOperationHandlers = createOperationHandlers(memoryOperations);
 export const memoryModuleGroup = defineToolModule({
@@ -59,6 +89,36 @@ export const memoryModuleGroup = defineToolModule({
                     description: "Poll until the READY. prompt appears",
                     arguments: { op: "wait_for_text", pattern: "READY." },
                 },
+                {
+                    name: "Disassemble entry point",
+                    description: "Disassemble 20 instructions starting at $0810",
+                    arguments: { op: "disassemble", address: "$0810", instructionCount: 20 },
+                },
+                {
+                    name: "Copy screen RAM",
+                    description: "Copy 1000 bytes of screen RAM to a scratch area",
+                    arguments: { op: "copy_memory", source: "$0400", dest: "$C000", length: 1000 },
+                },
+                {
+                    name: "Clear screen RAM",
+                    description: "Fill screen RAM with space character ($20)",
+                    arguments: { op: "fill_memory", address: "$0400", length: 1000, pattern: "20" },
+                },
+                {
+                    name: "Search for RTS",
+                    description: "Find RTS ($60) instructions in BASIC ROM",
+                    arguments: { op: "search_memory", startAddress: "$A000", endAddress: "$BFFF", pattern: "60" },
+                },
+                {
+                    name: "Compare two buffers",
+                    description: "Check whether two 256-byte regions differ",
+                    arguments: { op: "compare_memory", address1: "$C000", address2: "$C100", length: 256 },
+                },
+                {
+                    name: "Save PRG dump",
+                    description: "Save $0801-$CFFF as a PRG file",
+                    arguments: { op: "save_memory", startAddress: "$0801", endAddress: "$CFFF", filePath: "/tmp/dump.prg" },
+                },
             ],
             execute: createOperationDispatcher("c64_memory", memoryOperationHandlers),
         },

package/dist/tools/responses.js

@@ -1,5 +1,5 @@
 export function textResult(text, metadata) {
-    return {
+    const result = {
         content: [
             {
                 type: "text",
@@ -8,6 +8,19 @@ export function textResult(text, metadata) {
         ],
         metadata,
     };
+    if (metadata !== undefined) {
+        return {
+            ...result,
+            structuredContent: {
+                type: "json",
+                data: {
+                    message: text,
+                    ...metadata,
+                },
+            },
+        };
+    }
+    return result;
 }
 export function jsonResult(data, metadata) {
     const text = typeof data === "string"

package/dist/tools/schema.js

@@ -195,15 +195,14 @@ function isPlainObject(value) {
 }
 export function objectSchema(options) {
     const required = options.required ?? [];
+    const additionalProperties = options.additionalProperties ?? false;
     const propertyEntries = Object.entries(options.properties).map(([key, schema]) => [key, schema.jsonSchema]);
     const jsonSchema = {
         type: "object",
         ...(options.description ? { description: options.description } : {}),
         properties: Object.fromEntries(propertyEntries),
         ...(required.length > 0 ? { required: required.map((key) => key) } : {}),
-        ...(options.additionalProperties !== undefined
-            ? { additionalProperties: options.additionalProperties }
-            : { additionalProperties: false }),
+        additionalProperties,
     };
     return createSchema(jsonSchema, (value, path) => {
         ensureType(isPlainObject(value), "Expected an object", path, {
@@ -234,7 +233,7 @@ export function objectSchema(options) {
                 }
             }
         }
-        if (options.additionalProperties === false) {
+        if (!additionalProperties) {
             for (const key of Object.keys(input)) {
                 if (!hasOwn.call(options.properties, key)) {
                     throw new ToolValidationError("Unexpected property", {
@@ -243,7 +242,7 @@ export function objectSchema(options) {
                 }
             }
         }
-        else if (options.additionalProperties === true) {
+        else {
             for (const key of Object.keys(input)) {
                 if (!hasOwn.call(options.properties, key)) {
                     result[key] = input[key];

package/dist/{assemblyConverter.js → tools/translation/assembler.js}

@@ -6,6 +6,7 @@ Licensed under the GNU General Public License v2.0 or later.
 See <https://www.gnu.org/licenses/> for details.
 */
 import { Buffer } from "node:buffer";
+import { OPCODE_INVENTORY } from "./opcodeInventory.js";
 export class AssemblyError extends Error {
     constructor(message, location) {
         super(`${location.file}:${location.line}: ${message}`);
@@ -20,6 +21,7 @@ var AddressingMode;
     AddressingMode["ZeroPage"] = "zeroPage";
     AddressingMode["ZeroPageX"] = "zeroPageX";
     AddressingMode["ZeroPageY"] = "zeroPageY";
+    AddressingMode["ZeroPageS"] = "zeroPageS";
     AddressingMode["Absolute"] = "absolute";
     AddressingMode["AbsoluteX"] = "absoluteX";
     AddressingMode["AbsoluteY"] = "absoluteY";
@@ -77,6 +79,9 @@ const DIRECTIVE_ALIASES = {
 };
 const RELATIVE_ONLY = new Set(["BCC", "BCS", "BEQ", "BMI", "BNE", "BPL", "BVC", "BVS"]);
 export function assemblyToPrg(source, options) {
+    return assemblyToPrgDetailed(source, options).prg;
+}
+export function assemblyToPrgDetailed(source, options) {
     const normalized = normalizeSource(source);
     const loadAddress = options?.loadAddress ?? DEFAULT_LOAD_ADDRESS;
     const rootFile = options?.fileName ?? "(input)";
@@ -86,7 +91,7 @@ export function assemblyToPrg(source, options) {
     const assembler = new Assembler(statements, loadAddress);
     assembler.runPass(0);
     assembler.runPass(1);
-    return assembler.buildPrg();
+    return { prg: assembler.buildPrg(), symbols: assembler.getSymbols() };
 }
 function normalizeSource(input) {
     return input.replace(/\r\n?/g, "\n");
@@ -516,7 +521,19 @@ function parseOperand(stream) {
     }
     if (first.kind === "punct" && first.value === "(") {
         stream.consumePunct("(");
-        const expr = parseExpression(stream, new Set([")"]));
+        const expr = parseExpression(stream, new Set([",", ")"]));
+        if (stream.peek()?.kind === "punct" && stream.peek()?.value === ",") {
+            stream.consumePunct(",");
+            const register = stream.consumeSymbol("Expected X before ')'").toUpperCase();
+            if (register !== "X") {
+                throw new Error("Only X is allowed inside pre-indexed indirect operands");
+            }
+            stream.consumePunct(")", "Expected ')' to close indirect operand");
+            if (!stream.isAtEnd()) {
+                throw new Error("Unexpected tokens after indirect operand");
+            }
+            return { kind: "indirect", expr, register: "X" };
+        }
         stream.consumePunct(")", "Expected ')' to close indirect operand");
         if (stream.isAtEnd()) {
             return { kind: "indirect", expr };
@@ -542,9 +559,9 @@ function parseOperand(stream) {
     const next = stream.peek();
     if (next && next.kind === "punct" && next.value === ",") {
         stream.consumePunct(",");
-        const register = stream.consumeSymbol("Expected X or Y after comma").toUpperCase();
-        if (register !== "X" && register !== "Y") {
-            throw new Error("Only X or Y are allowed after comma");
+        const register = stream.consumeSymbol("Expected X, Y, or S after comma").toUpperCase();
+        if (register !== "X" && register !== "Y" && register !== "S") {
+            throw new Error("Only X, Y, or S are allowed after comma");
         }
         return { kind: "expression", expr, register };
     }
@@ -608,6 +625,9 @@ class SymbolTable {
         }
         return this.globals.get(label);
     }
+    allGlobals() {
+        return this.globals;
+    }
     ensureLocalScope(scope) {
         if (!this.locals.has(scope)) {
             this.locals.set(scope, new Map());
@@ -658,6 +678,9 @@ class Assembler {
         header.writeUInt16LE(start, 0);
         return Buffer.concat([header, Buffer.from(body)]);
     }
+    getSymbols() {
+        return this.symbolTable.allGlobals();
+    }
     processLine(line, pass) {
         for (const label of line.labels) {
             if (pass === 0) {
@@ -821,6 +844,7 @@ class Assembler {
             case AddressingMode.ZeroPage:
             case AddressingMode.ZeroPageX:
             case AddressingMode.ZeroPageY:
+            case AddressingMode.ZeroPageS:
             case AddressingMode.IndirectX:
             case AddressingMode.IndirectY:
                 this.writeByte(info.value ?? 0, location);
@@ -1031,6 +1055,11 @@ function chooseAddressingMode(mnemonic, operand, value, pass, location) {
                     return AddressingMode.AbsoluteY;
                 }
             }
+            else if (register === "S") {
+                if (available.has(AddressingMode.ZeroPageS)) {
+                    return AddressingMode.ZeroPageS;
+                }
+            }
             else {
                 if (available.has(AddressingMode.ZeroPage) && value !== undefined && fitsByte(value)) {
                     return AddressingMode.ZeroPage;
@@ -1057,6 +1086,7 @@ function instructionSize(mode) {
         case AddressingMode.ZeroPage:
         case AddressingMode.ZeroPageX:
         case AddressingMode.ZeroPageY:
+        case AddressingMode.ZeroPageS:
         case AddressingMode.IndirectX:
         case AddressingMode.IndirectY:
         case AddressingMode.Relative:
@@ -1086,6 +1116,7 @@ function normalizeOperandValue(mode, value, locationCounterOrLocation, locationM
         case AddressingMode.ZeroPage:
         case AddressingMode.ZeroPageX:
         case AddressingMode.ZeroPageY:
+        case AddressingMode.ZeroPageS:
         case AddressingMode.IndirectX:
         case AddressingMode.IndirectY:
             if (value === undefined)
@@ -1132,168 +1163,40 @@ function fitsByte(value) {
 function formatHex(value) {
     return `$${value.toString(16).toUpperCase().padStart(4, "0")}`;
 }
+const OPCODE_MODE_TO_ADDRESSING_MODE = {
+    implied: AddressingMode.Implied,
+    accumulator: AddressingMode.Accumulator,
+    immediate: AddressingMode.Immediate,
+    zeroPage: AddressingMode.ZeroPage,
+    zeroPageX: AddressingMode.ZeroPageX,
+    zeroPageY: AddressingMode.ZeroPageY,
+    zeroPageS: AddressingMode.ZeroPageS,
+    absolute: AddressingMode.Absolute,
+    absoluteX: AddressingMode.AbsoluteX,
+    absoluteY: AddressingMode.AbsoluteY,
+    indirect: AddressingMode.Indirect,
+    indirectX: AddressingMode.IndirectX,
+    indirectY: AddressingMode.IndirectY,
+    relative: AddressingMode.Relative,
+};
 function buildInstructionTable() {
     const table = new Map();
-    for (const entry of INSTRUCTION_DATA) {
-        const mnemonic = entry.mnemonic;
-        if (!table.has(mnemonic)) {
-            table.set(mnemonic, new Map());
+    const entryByMnemonicAndMode = new Map();
+    for (const entry of OPCODE_INVENTORY) {
+        const mode = OPCODE_MODE_TO_ADDRESSING_MODE[entry.mode];
+        const key = `${entry.mnemonic}\u0000${mode}`;
+        const existing = entryByMnemonicAndMode.get(key);
+        // The inventory is sorted by opcode, but assembly should prefer official
+        // encodings over undocumented aliases for duplicate mnemonic/mode pairs.
+        if (existing && (!existing.illegal || entry.illegal)) {
+            continue;
+        }
+        entryByMnemonicAndMode.set(key, { opcode: entry.opcode, illegal: entry.illegal });
+        if (!table.has(entry.mnemonic)) {
+            table.set(entry.mnemonic, new Map());
         }
-        table.get(mnemonic).set(entry.mode, entry.opcode);
+        table.get(entry.mnemonic).set(mode, entry.opcode);
     }
     return table;
 }
-const INSTRUCTION_DATA = [
-    { mnemonic: "ADC", mode: AddressingMode.Immediate, opcode: 0x69 },
-    { mnemonic: "ADC", mode: AddressingMode.ZeroPage, opcode: 0x65 },
-    { mnemonic: "ADC", mode: AddressingMode.ZeroPageX, opcode: 0x75 },
-    { mnemonic: "ADC", mode: AddressingMode.Absolute, opcode: 0x6d },
-    { mnemonic: "ADC", mode: AddressingMode.AbsoluteX, opcode: 0x7d },
-    { mnemonic: "ADC", mode: AddressingMode.AbsoluteY, opcode: 0x79 },
-    { mnemonic: "ADC", mode: AddressingMode.IndirectX, opcode: 0x61 },
-    { mnemonic: "ADC", mode: AddressingMode.IndirectY, opcode: 0x71 },
-    { mnemonic: "AND", mode: AddressingMode.Immediate, opcode: 0x29 },
-    { mnemonic: "AND", mode: AddressingMode.ZeroPage, opcode: 0x25 },
-    { mnemonic: "AND", mode: AddressingMode.ZeroPageX, opcode: 0x35 },
-    { mnemonic: "AND", mode: AddressingMode.Absolute, opcode: 0x2d },
-    { mnemonic: "AND", mode: AddressingMode.AbsoluteX, opcode: 0x3d },
-    { mnemonic: "AND", mode: AddressingMode.AbsoluteY, opcode: 0x39 },
-    { mnemonic: "AND", mode: AddressingMode.IndirectX, opcode: 0x21 },
-    { mnemonic: "AND", mode: AddressingMode.IndirectY, opcode: 0x31 },
-    { mnemonic: "ASL", mode: AddressingMode.Accumulator, opcode: 0x0a },
-    { mnemonic: "ASL", mode: AddressingMode.ZeroPage, opcode: 0x06 },
-    { mnemonic: "ASL", mode: AddressingMode.ZeroPageX, opcode: 0x16 },
-    { mnemonic: "ASL", mode: AddressingMode.Absolute, opcode: 0x0e },
-    { mnemonic: "ASL", mode: AddressingMode.AbsoluteX, opcode: 0x1e },
-    { mnemonic: "BIT", mode: AddressingMode.ZeroPage, opcode: 0x24 },
-    { mnemonic: "BIT", mode: AddressingMode.Absolute, opcode: 0x2c },
-    { mnemonic: "BPL", mode: AddressingMode.Relative, opcode: 0x10 },
-    { mnemonic: "BMI", mode: AddressingMode.Relative, opcode: 0x30 },
-    { mnemonic: "BVC", mode: AddressingMode.Relative, opcode: 0x50 },
-    { mnemonic: "BVS", mode: AddressingMode.Relative, opcode: 0x70 },
-    { mnemonic: "BCC", mode: AddressingMode.Relative, opcode: 0x90 },
-    { mnemonic: "BCS", mode: AddressingMode.Relative, opcode: 0xb0 },
-    { mnemonic: "BNE", mode: AddressingMode.Relative, opcode: 0xd0 },
-    { mnemonic: "BEQ", mode: AddressingMode.Relative, opcode: 0xf0 },
-    { mnemonic: "BRK", mode: AddressingMode.Implied, opcode: 0x00 },
-    { mnemonic: "CLC", mode: AddressingMode.Implied, opcode: 0x18 },
-    { mnemonic: "CLD", mode: AddressingMode.Implied, opcode: 0xd8 },
-    { mnemonic: "CLI", mode: AddressingMode.Implied, opcode: 0x58 },
-    { mnemonic: "CLV", mode: AddressingMode.Implied, opcode: 0xb8 },
-    { mnemonic: "CMP", mode: AddressingMode.Immediate, opcode: 0xc9 },
-    { mnemonic: "CMP", mode: AddressingMode.ZeroPage, opcode: 0xc5 },
-    { mnemonic: "CMP", mode: AddressingMode.ZeroPageX, opcode: 0xd5 },
-    { mnemonic: "CMP", mode: AddressingMode.Absolute, opcode: 0xcd },
-    { mnemonic: "CMP", mode: AddressingMode.AbsoluteX, opcode: 0xdd },
-    { mnemonic: "CMP", mode: AddressingMode.AbsoluteY, opcode: 0xd9 },
-    { mnemonic: "CMP", mode: AddressingMode.IndirectX, opcode: 0xc1 },
-    { mnemonic: "CMP", mode: AddressingMode.IndirectY, opcode: 0xd1 },
-    { mnemonic: "CPX", mode: AddressingMode.Immediate, opcode: 0xe0 },
-    { mnemonic: "CPX", mode: AddressingMode.ZeroPage, opcode: 0xe4 },
-    { mnemonic: "CPX", mode: AddressingMode.Absolute, opcode: 0xec },
-    { mnemonic: "CPY", mode: AddressingMode.Immediate, opcode: 0xc0 },
-    { mnemonic: "CPY", mode: AddressingMode.ZeroPage, opcode: 0xc4 },
-    { mnemonic: "CPY", mode: AddressingMode.Absolute, opcode: 0xcc },
-    { mnemonic: "DEC", mode: AddressingMode.ZeroPage, opcode: 0xc6 },
-    { mnemonic: "DEC", mode: AddressingMode.ZeroPageX, opcode: 0xd6 },
-    { mnemonic: "DEC", mode: AddressingMode.Absolute, opcode: 0xce },
-    { mnemonic: "DEC", mode: AddressingMode.AbsoluteX, opcode: 0xde },
-    { mnemonic: "DEX", mode: AddressingMode.Implied, opcode: 0xca },
-    { mnemonic: "DEY", mode: AddressingMode.Implied, opcode: 0x88 },
-    { mnemonic: "EOR", mode: AddressingMode.Immediate, opcode: 0x49 },
-    { mnemonic: "EOR", mode: AddressingMode.ZeroPage, opcode: 0x45 },
-    { mnemonic: "EOR", mode: AddressingMode.ZeroPageX, opcode: 0x55 },
-    { mnemonic: "EOR", mode: AddressingMode.Absolute, opcode: 0x4d },
-    { mnemonic: "EOR", mode: AddressingMode.AbsoluteX, opcode: 0x5d },
-    { mnemonic: "EOR", mode: AddressingMode.AbsoluteY, opcode: 0x59 },
-    { mnemonic: "EOR", mode: AddressingMode.IndirectX, opcode: 0x41 },
-    { mnemonic: "EOR", mode: AddressingMode.IndirectY, opcode: 0x51 },
-    { mnemonic: "INC", mode: AddressingMode.ZeroPage, opcode: 0xe6 },
-    { mnemonic: "INC", mode: AddressingMode.ZeroPageX, opcode: 0xf6 },
-    { mnemonic: "INC", mode: AddressingMode.Absolute, opcode: 0xee },
-    { mnemonic: "INC", mode: AddressingMode.AbsoluteX, opcode: 0xfe },
-    { mnemonic: "INX", mode: AddressingMode.Implied, opcode: 0xe8 },
-    { mnemonic: "INY", mode: AddressingMode.Implied, opcode: 0xc8 },
-    { mnemonic: "JMP", mode: AddressingMode.Absolute, opcode: 0x4c },
-    { mnemonic: "JMP", mode: AddressingMode.Indirect, opcode: 0x6c },
-    { mnemonic: "JSR", mode: AddressingMode.Absolute, opcode: 0x20 },
-    { mnemonic: "LDA", mode: AddressingMode.Immediate, opcode: 0xa9 },
-    { mnemonic: "LDA", mode: AddressingMode.ZeroPage, opcode: 0xa5 },
-    { mnemonic: "LDA", mode: AddressingMode.ZeroPageX, opcode: 0xb5 },
-    { mnemonic: "LDA", mode: AddressingMode.Absolute, opcode: 0xad },
-    { mnemonic: "LDA", mode: AddressingMode.AbsoluteX, opcode: 0xbd },
-    { mnemonic: "LDA", mode: AddressingMode.AbsoluteY, opcode: 0xb9 },
-    { mnemonic: "LDA", mode: AddressingMode.IndirectX, opcode: 0xa1 },
-    { mnemonic: "LDA", mode: AddressingMode.IndirectY, opcode: 0xb1 },
-    { mnemonic: "LDX", mode: AddressingMode.Immediate, opcode: 0xa2 },
-    { mnemonic: "LDX", mode: AddressingMode.ZeroPage, opcode: 0xa6 },
-    { mnemonic: "LDX", mode: AddressingMode.ZeroPageY, opcode: 0xb6 },
-    { mnemonic: "LDX", mode: AddressingMode.Absolute, opcode: 0xae },
-    { mnemonic: "LDX", mode: AddressingMode.AbsoluteY, opcode: 0xbe },
-    { mnemonic: "LDY", mode: AddressingMode.Immediate, opcode: 0xa0 },
-    { mnemonic: "LDY", mode: AddressingMode.ZeroPage, opcode: 0xa4 },
-    { mnemonic: "LDY", mode: AddressingMode.ZeroPageX, opcode: 0xb4 },
-    { mnemonic: "LDY", mode: AddressingMode.Absolute, opcode: 0xac },
-    { mnemonic: "LDY", mode: AddressingMode.AbsoluteX, opcode: 0xbc },
-    { mnemonic: "LSR", mode: AddressingMode.Accumulator, opcode: 0x4a },
-    { mnemonic: "LSR", mode: AddressingMode.ZeroPage, opcode: 0x46 },
-    { mnemonic: "LSR", mode: AddressingMode.ZeroPageX, opcode: 0x56 },
-    { mnemonic: "LSR", mode: AddressingMode.Absolute, opcode: 0x4e },
-    { mnemonic: "LSR", mode: AddressingMode.AbsoluteX, opcode: 0x5e },
-    { mnemonic: "NOP", mode: AddressingMode.Implied, opcode: 0xea },
-    { mnemonic: "ORA", mode: AddressingMode.Immediate, opcode: 0x09 },
-    { mnemonic: "ORA", mode: AddressingMode.ZeroPage, opcode: 0x05 },
-    { mnemonic: "ORA", mode: AddressingMode.ZeroPageX, opcode: 0x15 },
-    { mnemonic: "ORA", mode: AddressingMode.Absolute, opcode: 0x0d },
-    { mnemonic: "ORA", mode: AddressingMode.AbsoluteX, opcode: 0x1d },
-    { mnemonic: "ORA", mode: AddressingMode.AbsoluteY, opcode: 0x19 },
-    { mnemonic: "ORA", mode: AddressingMode.IndirectX, opcode: 0x01 },
-    { mnemonic: "ORA", mode: AddressingMode.IndirectY, opcode: 0x11 },
-    { mnemonic: "PHA", mode: AddressingMode.Implied, opcode: 0x48 },
-    { mnemonic: "PHP", mode: AddressingMode.Implied, opcode: 0x08 },
-    { mnemonic: "PLA", mode: AddressingMode.Implied, opcode: 0x68 },
-    { mnemonic: "PLP", mode: AddressingMode.Implied, opcode: 0x28 },
-    { mnemonic: "ROL", mode: AddressingMode.Accumulator, opcode: 0x2a },
-    { mnemonic: "ROL", mode: AddressingMode.ZeroPage, opcode: 0x26 },
-    { mnemonic: "ROL", mode: AddressingMode.ZeroPageX, opcode: 0x36 },
-    { mnemonic: "ROL", mode: AddressingMode.Absolute, opcode: 0x2e },
-    { mnemonic: "ROL", mode: AddressingMode.AbsoluteX, opcode: 0x3e },
-    { mnemonic: "ROR", mode: AddressingMode.Accumulator, opcode: 0x6a },
-    { mnemonic: "ROR", mode: AddressingMode.ZeroPage, opcode: 0x66 },
-    { mnemonic: "ROR", mode: AddressingMode.ZeroPageX, opcode: 0x76 },
-    { mnemonic: "ROR", mode: AddressingMode.Absolute, opcode: 0x6e },
-    { mnemonic: "ROR", mode: AddressingMode.AbsoluteX, opcode: 0x7e },
-    { mnemonic: "RTI", mode: AddressingMode.Implied, opcode: 0x40 },
-    { mnemonic: "RTS", mode: AddressingMode.Implied, opcode: 0x60 },
-    { mnemonic: "SBC", mode: AddressingMode.Immediate, opcode: 0xe9 },
-    { mnemonic: "SBC", mode: AddressingMode.ZeroPage, opcode: 0xe5 },
-    { mnemonic: "SBC", mode: AddressingMode.ZeroPageX, opcode: 0xf5 },
-    { mnemonic: "SBC", mode: AddressingMode.Absolute, opcode: 0xed },
-    { mnemonic: "SBC", mode: AddressingMode.AbsoluteX, opcode: 0xfd },
-    { mnemonic: "SBC", mode: AddressingMode.AbsoluteY, opcode: 0xf9 },
-    { mnemonic: "SBC", mode: AddressingMode.IndirectX, opcode: 0xe1 },
-    { mnemonic: "SBC", mode: AddressingMode.IndirectY, opcode: 0xf1 },
-    { mnemonic: "SEC", mode: AddressingMode.Implied, opcode: 0x38 },
-    { mnemonic: "SED", mode: AddressingMode.Implied, opcode: 0xf8 },
-    { mnemonic: "SEI", mode: AddressingMode.Implied, opcode: 0x78 },
-    { mnemonic: "STA", mode: AddressingMode.ZeroPage, opcode: 0x85 },
-    { mnemonic: "STA", mode: AddressingMode.ZeroPageX, opcode: 0x95 },
-    { mnemonic: "STA", mode: AddressingMode.Absolute, opcode: 0x8d },
-    { mnemonic: "STA", mode: AddressingMode.AbsoluteX, opcode: 0x9d },
-    { mnemonic: "STA", mode: AddressingMode.AbsoluteY, opcode: 0x99 },
-    { mnemonic: "STA", mode: AddressingMode.IndirectX, opcode: 0x81 },
-    { mnemonic: "STA", mode: AddressingMode.IndirectY, opcode: 0x91 },
-    { mnemonic: "STX", mode: AddressingMode.ZeroPage, opcode: 0x86 },
-    { mnemonic: "STX", mode: AddressingMode.ZeroPageY, opcode: 0x96 },
-    { mnemonic: "STX", mode: AddressingMode.Absolute, opcode: 0x8e },
-    { mnemonic: "STY", mode: AddressingMode.ZeroPage, opcode: 0x84 },
-    { mnemonic: "STY", mode: AddressingMode.ZeroPageX, opcode: 0x94 },
-    { mnemonic: "STY", mode: AddressingMode.Absolute, opcode: 0x8c },
-    { mnemonic: "TAX", mode: AddressingMode.Implied, opcode: 0xaa },
-    { mnemonic: "TAY", mode: AddressingMode.Implied, opcode: 0xa8 },
-    { mnemonic: "TSX", mode: AddressingMode.Implied, opcode: 0xba },
-    { mnemonic: "TXA", mode: AddressingMode.Implied, opcode: 0x8a },
-    { mnemonic: "TXS", mode: AddressingMode.Implied, opcode: 0x9a },
-    { mnemonic: "TYA", mode: AddressingMode.Implied, opcode: 0x98 },
-];
 const INSTRUCTION_TABLE = buildInstructionTable();

package/dist/{basicConverter.js → tools/translation/basicTokenizer.js}

@@ -6,7 +6,7 @@ Licensed under the GNU General Public License v2.0 or later.
 See <https://www.gnu.org/licenses/> for details.
 */
 import { Buffer } from "node:buffer";
-import { asciiToPetscii, encodeStringWithNames } from "./petscii.js";
+import { asciiToPetscii, encodeStringWithNames } from "../../petscii.js";
 const DEFAULT_START_ADDRESS = 0x0801;
 const REM_TOKEN = 0x8f;
 const TOKEN_TABLE = buildTokenTable();