pine_load_state

Instructions

Implementation Reference

• src/tools.ts:241-244 (handler)

  Handler for the pine_load_state tool. Calls pine.loadState(slot) and returns a confirmation message.

  case "pine_load_state": {
    await pine.loadState(p.slot as number);
    return ok(`Load state triggered for slot ${p.slot}`);
  }

• src/tools.ts:146-156 (schema)

  Input schema definition for the pine_load_state tool. Requires a 'slot' integer (0-255).

  {
    name: "pine_load_state",
    description: "Trigger the emulator to load a previously-saved state from a numbered slot.",
    inputSchema: {
      type: "object",
      required: ["slot"],
      properties: {
        slot: { type: "integer", minimum: 0, maximum: 255, description: "Save state slot (0-255)" },
      },
    },
  },

• src/tools.ts:174-250 (registration)

  The tool is registered via setRequestHandler(CallToolRequestSchema) inside the registerTools() function. The switch/case dispatches to the pine_load_state handler on line 241.

    server.setRequestHandler(CallToolRequestSchema, async (req) => {
      const { name, arguments: args = {} } = req.params;
      const p = args as Record<string, unknown>;
      const addr = () => p.address as number;
  
      switch (name) {
        case "pine_ping": {
          const v = await pine.getVersion();
          return ok(`OK — emulator: ${v}`);
        }
  
        case "pine_get_info": {
          const [title, id, uuid, gameVer, status] = await Promise.all([
            pine.getTitle().catch(() => "(unavailable)"),
            pine.getId().catch(() => "(unavailable)"),
            pine.getUuid().catch(() => "(unavailable)"),
            pine.getGameVersion().catch(() => "(unavailable)"),
            pine.getStatus(),
          ]);
          return ok(
            `Title:        ${title}\n` +
            `Serial:       ${id}\n` +
            `Disc CRC:     ${uuid}\n` +
            `Game version: ${gameVer}\n` +
            `Status:       ${status}`,
          );
        }
  
        case "pine_get_status": {
          return ok(`Status: ${await pine.getStatus()}`);
        }
  
        case "pine_read8":  return ok(`${addrHex(addr())}: ${fmtHex(await pine.read8(addr()))}`);
        case "pine_read16": return ok(`${addrHex(addr())}: ${fmtHex(await pine.read16(addr()))}`);
        case "pine_read32": return ok(`${addrHex(addr())}: ${fmtHex(await pine.read32(addr()))}`);
        case "pine_read64": return ok(`${addrHex(addr())}: ${fmtHex(await pine.read64(addr()))}`);
  
        case "pine_write8": {
          await pine.write8(addr(), p.value as number);
          return ok(`Wrote ${fmtHex(p.value as number)} → ${addrHex(addr())}`);
        }
        case "pine_write16": {
          await pine.write16(addr(), p.value as number);
          return ok(`Wrote ${fmtHex(p.value as number)} → ${addrHex(addr())}`);
        }
        case "pine_write32": {
          await pine.write32(addr(), p.value as number);
          return ok(`Wrote ${fmtHex(p.value as number)} → ${addrHex(addr())}`);
        }
        case "pine_write64": {
          const v = BigInt(p.value as string);
          await pine.write64(addr(), v);
          return ok(`Wrote ${fmtHex(v)} → ${addrHex(addr())}`);
        }
  
        case "pine_read_range": {
          const bytes = await pine.readRange(p.address as number, p.length as number);
          const hex = Array.from(bytes)
            .map((b) => b.toString(16).padStart(2, "0").toUpperCase())
            .join(" ");
          return ok(`${addrHex(p.address as number)} [${bytes.length} bytes]:\n${hex}`);
        }
  
        case "pine_save_state": {
          await pine.saveState(p.slot as number);
          return ok(`Save state triggered for slot ${p.slot}`);
        }
        case "pine_load_state": {
          await pine.loadState(p.slot as number);
          return ok(`Load state triggered for slot ${p.slot}`);
        }
  
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }

• src/pine.ts:278-281 (helper)

  Low-level helper on PineClient that sends the LoadState opcode (0x0A) with the slot number as a single byte argument.

  async loadState(slot: number): Promise<void> {
    const args = Buffer.alloc(1); args.writeUInt8(slot, 0);
    await this.call(Op.LoadState, args);
  }