표시는 그려질 뿐, 명령이 아니야

  /// The guides in one reply: its last Map block, plus every place named with
  /// a maps.apple.com link outside code. Nil when the reply puts nothing on
  /// the map.
  public static func from(reply: String) -> MapGuides? {
    var guides = hostInputBlocks(in: reply).reversed().lazy.compactMap { try? Self.parse(json: Data($0.utf8)) }
      .first ?? MapGuides(shapes: [])
    var pinned = Set(guides.places.map { Self.key($0.coordinate, $0.label) })
    for place in linkedPlaces(in: reply) where guides.shapes.count < shapeLimit {
      guard pinned.insert(Self.key(place.coordinate, place.label)).inserted else { continue }
      guides.shapes.append(.place(at: place.coordinate, label: place.label))
    }
    return guides.shapes.isEmpty ? nil : guides
  }

import Foundation

// A minimal sketch: read a reply the way Pathfinder reads Pippa's,
// keeping only the LAST host-input Map block that parses, and skipping
// any shape that does not read (even one that is not an object at all)
// instead of guessing at it or throwing the whole block away.
struct Point { let lat: Double, lon: Double }
enum Shape { case place(Point, String?), area(Point, Double) }

func point(_ value: Any?) -> Point? {
  guard let pair = value as? [Double], pair.count == 2 else { return nil }
  let p = Point(lat: pair[0], lon: pair[1])
  let onGlobe = abs(p.lat) <= 90 && abs(p.lon) <= 180
  return onGlobe && !(p.lat == 0 && p.lon == 0) ? p : nil   // (0,0) is a bug, not a place
}

func mapBlocks(in reply: String) -> [String] {
  var blocks: [String] = [], open: [String]? = nil
  for raw in reply.components(separatedBy: "\n") {
    let line = raw.trimmingCharacters(in: .whitespaces)
    if let body = open {
      if line.hasPrefix("```") { blocks.append(body.joined(separator: "\n")); open = nil }
      else { open = body + [raw] }
    } else if line.hasPrefix("```host-input") && (line.contains("\"Map\"") || !line.contains("label=")) {
      open = []
    }
  }
  return blocks
}

func shapes(_ json: String) -> [Shape]? {
  guard let object = try? JSONSerialization.jsonObject(with: Data(json.utf8)) as? [String: Any],
    let raw = object["guides"] as? [Any] else { return nil }
  return raw.prefix(40).compactMap { $0 as? [String: Any] }.compactMap { item in
    switch item["type"] as? String {
    case "place": return point(item["at"]).map { .place($0, item["label"] as? String) }
    case "area":
      guard let c = point(item["center"]), let r = item["radius_m"] as? Double, r > 0 else { return nil }
      return .area(c, min(r, 50_000))
    default: return nil
    }
  }
}

let reply = """
Here are two ideas.
```host-input label="Map"
{"guides":[{"type":"place","at":[48.8584,2.2945],"label":"first try"}]}
```
On second thought, this one:
```host-input label="Map"
{"guides":[{"type":"place","at":[48.8606,2.3376],"label":"Louvre"},
           {"type":"place","at":[0,0],"label":"broken"}, "not a shape",
           {"type":"area","center":[48.8606,2.3376],"radius_m":900000},
           {"type":"spiral","at":[48.86,2.33]}]}
```
"""

let drawn = mapBlocks(in: reply).reversed().lazy.compactMap(shapes).first ?? []
for shape in drawn {
  switch shape {
  case let .place(p, label): print("place", label ?? "-", p.lat, p.lon)
  case let .area(c, r): print("area", c.lat, c.lon, "radius", r)
  }
}
print("shapes drawn:", drawn.count)

// Output:
// place Louvre 48.8606 2.3376
// area 48.8606 2.3376 radius 50000.0
// shapes drawn: 2