c64bridge 0.9.1 → 0.9.2

package/dist/c64Client.js

@@ -8,8 +8,8 @@ See <https://www.gnu.org/licenses/> for details.
 import { Buffer } from "node:buffer";
 import { createSocket } from "node:dgram";
 import axios from "axios";
-import { basicToPrg } from "./tools/basicTokenizer.js";
-import { assemblyToPrg } from "./tools/assember.js";
+import { basicToPrg } from "./tools/translation/basicTokenizer.js";
+import { assemblyToPrg } from "./tools/translation/assembler.js";
 import { screenCodesToAscii } from "./petscii.js";
 import { resolveAddressSymbol } from "./knowledge.js";
 import { createAllFacades, createFacade } from "./device.js";
@@ -28,6 +28,17 @@ const DEFAULT_TEXT_FOREGROUND = 1;
 const DEFAULT_BORDER_COLOR = 6;
 const DEFAULT_BACKGROUND_COLOR = 0;
 const SPACE_SCREEN_CODE = 0x20;
+function validateMemoryRange(address, length) {
+    if (!Number.isInteger(address) || address < 0 || address > 0xffff) {
+        throw new Error("Address must be within 0x0000 - 0xFFFF");
+    }
+    if (!Number.isInteger(length) || length <= 0) {
+        throw new Error("Length must be greater than zero");
+    }
+    if (address + length - 1 > 0xffff) {
+        throw new Error("Memory range must stay within 0x0000 - 0xFFFF");
+    }
+}
 export class C64Client {
     constructor(baseUrl, options = {}) {
         this.allFacades = new Map();
@@ -481,9 +492,7 @@ export class C64Client {
             const resolved = resolveAddressSymbol(addressInput);
             const address = resolved ?? this.parseNumeric(addressInput);
             const length = this.parseNumeric(lengthInput);
-            if (length <= 0) {
-                throw new Error("Length must be greater than zero");
-            }
+            validateMemoryRange(address, length);
             const rawBytes = await this.readMemoryRaw(address, length);
             const bytes = rawBytes.slice(0, length);
             return {
@@ -507,9 +516,7 @@ export class C64Client {
             const resolved = resolveAddressSymbol(addressInput);
             const address = resolved ?? this.parseNumeric(addressInput);
             const dataBuffer = this.hexStringToBuffer(bytesInput);
-            if (dataBuffer.length === 0) {
-                throw new Error("No bytes provided");
-            }
+            validateMemoryRange(address, dataBuffer.length);
             // Prefer PUT with hex data for up to 128 bytes; fall back to POST binary for larger writes
             const addrStr = this.formatAddress(address);
             try {
@@ -1467,6 +1474,7 @@ export class C64Client {
      * Public to allow advanced polling and monitoring use cases.
      */
     async readMemoryRaw(address, length) {
+        validateMemoryRange(address, length);
         try {
             const facade = await this.facadePromise;
             return await facade.readMemory(address, length);
@@ -1498,8 +1506,12 @@ export class C64Client {
      * keyboard-buffer injection) can avoid backend-specific paths.
      */
     async writeMemoryRaw(address, bytes) {
+        if (!Number.isInteger(address) || address < 0 || address > 0xffff) {
+            throw new Error("Address must be within 0x0000 - 0xFFFF");
+        }
         const facade = await this.facadePromise;
         const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+        validateMemoryRange(address, buf.length);
         await facade.writeMemory(address, buf);
     }
     /**
@@ -1695,17 +1707,27 @@ export class C64Client {
         const lower = trimmed.toLowerCase();
         let radix = 10;
         let literal = lower;
+        let pattern;
         if (lower.startsWith("$")) {
             radix = 16;
             literal = lower.slice(1);
+            pattern = /^[0-9a-f]+$/;
         }
         else if (lower.startsWith("0x")) {
             radix = 16;
             literal = lower.slice(2);
+            pattern = /^[0-9a-f]+$/;
         }
         else if (lower.startsWith("%")) {
             radix = 2;
             literal = lower.slice(1);
+            pattern = /^[01]+$/;
+        }
+        else {
+            pattern = /^[0-9]+$/;
+        }
+        if (!pattern.test(literal)) {
+            throw new Error(`Unable to parse numeric value "${value}"`);
         }
         const parsed = Number.parseInt(literal, radix);
         if (!Number.isFinite(parsed) || Number.isNaN(parsed) || parsed < 0) {
@@ -1739,6 +1761,9 @@ export class C64Client {
         if (cleaned.length % 2 !== 0) {
             throw new Error("Hex string must contain an even number of characters");
         }
+        if (!/^[0-9a-f]+$/.test(cleaned)) {
+            throw new Error("Hex string contains non-hexadecimal characters");
+        }
         return Buffer.from(cleaned, "hex");
     }
     hzToSidFrequency(hz, system = "PAL") {

package/dist/sidwaveCompiler.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 { assemblyToPrg } from "./tools/assember.js";
+import { assemblyToPrg } from "./tools/translation/assembler.js";
 import { midiToHz, noteNameToMidi } from "./sidwave.js";
 /**
  * Small SIDWAVE to PRG compiler: generates a 50/60Hz player that writes SID registers from a precomputed frame table.

package/dist/tools/input.js

@@ -1,4 +1,4 @@
-import { createOperationDispatcher, defineToolModule, } from "./types.js";
+import { createOperationDispatcher, defineToolModule, discriminatedUnionSchema, } from "./types.js";
 import { arraySchema, literalSchema, numberSchema, objectSchema, optionalSchema, stringSchema, } from "./schema.js";
 import { textResult } from "./responses.js";
 import { ToolValidationError, toolErrorResult, unknownErrorResult, } from "./errors.js";
@@ -285,7 +285,7 @@ export const inputModule = defineToolModule({
     domain: "input",
     summary: "Cross-platform keyboard input plus VICE-only joystick simulation.",
     supportedPlatforms: ["c64u", "vice"],
-    resources: ["c64://specs/assembly", "c64://specs/memory-map"],
+    resources: ["c64://guide/bootstrap", "c64://memory/map", "c64://io/cia/spec"],
     prompts: [],
     defaultTags: ["input"],
     workflowHints: [
@@ -298,16 +298,14 @@ export const inputModule = defineToolModule({
             name: "c64_input",
             description: "Keyboard buffer injection (cross-platform) and joystick simulation (VICE only).",
             summary: "Types text, taps keys, and simulates joystick movements.",
-            inputSchema: {
-                type: "object",
+            inputSchema: discriminatedUnionSchema({
                 description: "Input operations: write_text, key, joystick.",
-                oneOf: [
+                variants: [
                     writeTextArgsSchema.jsonSchema,
                     keyArgsSchema.jsonSchema,
                     joystickArgsSchema.jsonSchema,
                 ],
-                discriminator: { propertyName: "op" },
-            },
+            }),
             operationPlatforms: { joystick: ["vice"] },
             tags: ["input", "keyboard", "joystick"],
             examples: [

package/dist/tools/memory.js

@@ -5,8 +5,8 @@ import { defineToolModule, OPERATION_DISCRIMINATOR, } from "./types.js";
 import { booleanSchema, numberSchema, objectSchema, optionalSchema, stringSchema } from "./schema.js";
 import { jsonResult, textResult } from "./responses.js";
 import { ToolError, ToolExecutionError, ToolValidationError, toolErrorResult, unknownErrorResult, } from "./errors.js";
-import { disassemble, formatDisassembly } from "./disassembler.js";
-import { getViceSymbols } from "./symbolRegistry.js";
+import { disassemble, formatDisassembly } from "./translation/disassembler.js";
+import { getViceSymbols } from "./translation/symbolRegistry.js";
 import { resolveAddressSymbol } from "../knowledge.js";
 function toRecord(details) {
     if (details && typeof details === "object") {
@@ -39,6 +39,12 @@ function parseHexInternal(value, path) {
     if (cleaned.length === 0) {
         return { bytes: new Uint8Array(), canonical: "$" };
     }
+    if (!/^[0-9A-F]+$/.test(cleaned)) {
+        throw new ToolValidationError("Hex string contains non-hexadecimal characters", {
+            path,
+            details: { value },
+        });
+    }
     const bytes = Uint8Array.from(Buffer.from(cleaned, "hex"));
     return { bytes, canonical: `$${cleaned}` };
 }
@@ -399,6 +405,7 @@ async function executeDisassemble(rawArgs, ctx) {
         const length = parsed.length ?? 64;
         ctx.logger.info("Disassembling VICE memory", { address: parsed.address, length });
         const address = parseAddressArg(parsed.address, "$.address");
+        validateRangeWithinAddressSpace(address, length, "$.address");
         const bytes = await ctx.client.readMemoryRaw(address, length);
         const symbols = ctx.platform?.id === "vice" ? getViceSymbols() : undefined;
         const lines = disassemble(bytes, address, parsed.instructionCount, symbols);
@@ -597,6 +604,8 @@ async function executeCompareMemory(rawArgs, ctx) {
         const a2 = parseAddressArg(parsed.address2, "$.address2");
         const len = parsed.length;
         const maxDiffs = parsed.maxDiffs ?? 10;
+        validateRangeWithinAddressSpace(a1, len, "$.address1");
+        validateRangeWithinAddressSpace(a2, len, "$.address2");
         ctx.logger.info("Comparing memory regions", { a1: fmtAddr(a1), a2: fmtAddr(a2), len });
         const [r1, r2] = await Promise.all([
             ctx.client.readMemoryRaw(a1, len),

package/dist/tools/programRunners.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
-import { assemblyToPrgDetailed, AssemblyError } from "./assember.js";
-import { basicToPrg } from "./basicTokenizer.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";
 import { textResult } from "./responses.js";
 import { ToolExecutionError, ToolError, ToolValidationError, toolErrorResult, unknownErrorResult, } from "./errors.js";
 import { pollForProgramOutcome } from "./pollValidator.js";
-import { clearViceSymbols, setViceSymbols, parseViceSymbolFile } from "./symbolRegistry.js";
+import { clearViceSymbols, setViceSymbols, parseViceSymbolFile } from "./translation/symbolRegistry.js";
 function extractFailureDetails(details) {
     if (details === undefined || details === null) {
         return undefined;

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/{assember.js → 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";
@@ -519,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 };
@@ -545,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 };
     }
@@ -830,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);
@@ -1040,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;
@@ -1066,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:
@@ -1095,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)
@@ -1141,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/tools/{basicTokenizer.js → 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();