ed-mcp 0.4.0 → 0.5.1

package/dist/index.js

@@ -8,7 +8,11 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -3335,6 +3339,37 @@ var require_utils = __commonJS({
       }
       return output3.join("");
     }
+    function removeDotSegmentsRelative(path15) {
+      if (path15 === "" || path15[0] === "/") {
+        return removeDotSegments(path15);
+      }
+      const segments = path15.split("/");
+      const last = segments.length - 1;
+      const output3 = [];
+      let trailingDirectory = false;
+      for (let i = 0; i <= last; i++) {
+        const segment = segments[i];
+        if (segment === "." || segment === "..") {
+          if (segment === "..") {
+            if (output3.length !== 0 && output3[output3.length - 1] !== "..") {
+              output3.pop();
+            } else {
+              output3.push("..");
+            }
+          }
+          trailingDirectory = i === last;
+        } else {
+          output3.push(segment);
+        }
+      }
+      if (trailingDirectory && output3[output3.length - 1] !== "..") {
+        output3.push("");
+      }
+      if (output3.length === 0 || output3[0] === "" || output3[0].includes(":")) {
+        output3.unshift(".");
+      }
+      return output3.join("/");
+    }
     var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
     var HOST_DELIM_RE = /[@/?#:]/g;
     var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
@@ -3595,6 +3630,7 @@ var require_utils = __commonJS({
       encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
+      removeDotSegmentsRelative,
       isIPv4,
       isUUID,
       normalizeIPv6,
@@ -3818,16 +3854,18 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, removeDotSegmentsRelative, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
     var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
-    function decodeValidScheme(scheme) {
-      const decodedScheme = unescape(String(scheme));
-      if (!VALID_SCHEME.test(decodedScheme)) {
+    var MALFORMED_HOST_ERROR = "URI host is malformed.";
+    var FORBIDDEN_DOMAIN_HOST_CHARACTER = /[\0-\x20"#/:<>?@[\\\]^`{|}\x7F]/u;
+    function validateScheme(scheme) {
+      const stringScheme = String(scheme);
+      if (!VALID_SCHEME.test(stringScheme)) {
         throw new TypeError(MALFORMED_SCHEME_ERROR);
       }
-      return decodedScheme;
+      return stringScheme;
     }
     function normalize(uri, options) {
       if (typeof uri === "string") {
@@ -3864,6 +3902,9 @@ var require_fast_uri = __commonJS({
       const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
       const resolvedHost = resolved.host;
       const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      if (hasForbiddenDomainHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP)) {
+        throw new Error(MALFORMED_HOST_ERROR);
+      }
       canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
       const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
       if (resolved.error && !encodedASCIIHost) {
@@ -3905,14 +3946,15 @@ var require_fast_uri = __commonJS({
             if (relative.path[0] === "/") {
               target.path = removeDotSegments(relative.path);
             } else {
-              if ((base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0) && !base2.path) {
+              const baseHasAuthority = base2.userinfo !== void 0 || base2.host !== void 0 || base2.port !== void 0;
+              if (baseHasAuthority && !base2.path) {
                 target.path = "/" + relative.path;
               } else if (!base2.path) {
                 target.path = relative.path;
               } else {
                 target.path = base2.path.slice(0, base2.path.lastIndexOf("/") + 1) + relative.path;
               }
-              target.path = removeDotSegments(target.path);
+              target.path = base2.scheme === void 0 && !baseHasAuthority && target.path[0] !== "/" ? removeDotSegmentsRelative(target.path) : removeDotSegments(target.path);
             }
             target.query = relative.query;
           }
@@ -3950,12 +3992,13 @@ var require_fast_uri = __commonJS({
       const options = Object.assign({}, opts);
       const uriTokens = [];
       if (component.scheme) {
-        component.scheme = decodeValidScheme(component.scheme);
+        component.scheme = validateScheme(component.scheme);
       }
       const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
-      const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
+      const schemelessReference = (component.scheme === void 0 || options.reference === "suffix") && !hasAuthority;
+      const pathNoScheme = !options.skipEscape && schemelessReference;
       if (component.path !== void 0) {
         if (!options.skipEscape) {
           component.path = serializePathEncoding(component.path, pathNoScheme);
@@ -3964,7 +4007,7 @@ var require_fast_uri = __commonJS({
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
-        component.scheme = decodeValidScheme(component.scheme);
+        component.scheme = validateScheme(component.scheme);
         uriTokens.push(component.scheme, ":");
       }
       const authority = recomposeAuthority(component);
@@ -3980,9 +4023,9 @@ var require_fast_uri = __commonJS({
       if (component.path !== void 0) {
         let s = component.path;
         if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-          s = removeDotSegments(s);
+          s = schemelessReference && s[0] !== "/" ? removeDotSegmentsRelative(s) : removeDotSegments(s);
         }
-        if (pathNoScheme) {
+        if (schemelessReference) {
           s = serializePathEncoding(s, true);
         }
         if (authority === void 0 && s[0] === "/" && s[1] === "/") {
@@ -4029,16 +4072,34 @@ var require_fast_uri = __commonJS({
       return hasMalformedPercentEncoding(matches2[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches2[6]) || hasMalformedPercentEncoding(matches2[7]) || hasMalformedPercentEncoding(matches2[8]);
     }
     function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+      if (hasForbiddenDomainHost(parsed, options, schemeHandler, isIP)) {
+        parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+        return true;
+      }
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+        let url2;
         try {
-          parsed.host = new URL("http://" + parsed.host).hostname;
+          url2 = new URL("http://" + parsed.host);
         } catch (e) {
           parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
           return true;
         }
+        if (!isHostOnlyURL(url2)) {
+          parsed.error = parsed.error || MALFORMED_HOST_ERROR;
+          return true;
+        }
+        parsed.host = url2.hostname;
       }
       return false;
     }
+    function hasForbiddenDomainHost(parsed, options, schemeHandler, isIP) {
+      return Boolean(
+        parsed.host && isIP === false && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && FORBIDDEN_DOMAIN_HOST_CHARACTER.test(parsed.host)
+      );
+    }
+    function isHostOnlyURL(url2) {
+      return url2.username === "" && url2.password === "" && url2.port === "" && url2.pathname === "/" && url2.search === "" && url2.hash === "" && url2.hostname !== "";
+    }
     function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
@@ -4093,9 +4154,8 @@ var require_fast_uri = __commonJS({
         parsed.query = matches2[7];
         parsed.fragment = matches2[8];
         if (parsed.scheme !== void 0) {
-          const decodedScheme = unescape(parsed.scheme);
-          if (VALID_SCHEME.test(decodedScheme)) {
-            parsed.scheme = decodedScheme.toLowerCase();
+          if (VALID_SCHEME.test(parsed.scheme)) {
+            parsed.scheme = parsed.scheme.toLowerCase();
           } else {
             parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
             malformedScheme = true;
@@ -4123,7 +4183,7 @@ var require_fast_uri = __commonJS({
             malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
             parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
             if (malformedIPLiteral) {
-              parsed.error = parsed.error || "URI host is malformed.";
+              parsed.error = parsed.error || MALFORMED_HOST_ERROR;
               malformedAuthorityOrPort = true;
             }
           } else {
@@ -4151,7 +4211,7 @@ var require_fast_uri = __commonJS({
           if (!isIP) {
             host = normalizePercentEncoding(host.toLowerCase());
           }
-          parsed.host = reescapeHostDelimiters(host, isIP);
+          parsed.host = isIP || options.scheme !== "null" ? reescapeHostDelimiters(host, isIP) : host;
         }
         if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
           if (parsed.path) {
@@ -9803,7 +9863,7 @@ ${content.join("\n")}
 var version = {
   major: 4,
   minor: 6,
-  patch: 6
+  patch: 7
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -28692,7 +28752,7 @@ async function canonical(p) {
 }
 
 // src/version.ts
-var VERSION = "0.4.0";
+var VERSION = "0.5.1";
 
 // src/config.ts
 var ConfigError = class extends Error {
@@ -32080,25 +32140,159 @@ function parseSpanshJson(text) {
   return JSON.parse(text.replace(BIG_ID, '$1"$2"'));
 }
 
+// src/systems/sweep.ts
+function stationPad(s) {
+  if (s.has_large_pad || (s.large_pads ?? 0) > 0) return "L";
+  if ((s.medium_pads ?? 0) > 0) return "M";
+  if ((s.small_pads ?? 0) > 0) return "S";
+  return null;
+}
+var skipStation = (type) => type === "Drake-Class Carrier" || /Construction Depot/.test(type ?? "");
+function mapSystem(raw) {
+  const { x, y, z: z2 } = raw;
+  if (x == null || y == null || z2 == null) return null;
+  return {
+    name: raw.name,
+    id64: String(raw.id64),
+    coords: { x, y, z: z2 },
+    government: raw.government ?? null,
+    allegiance: raw.allegiance ?? null,
+    security: raw.security ?? null,
+    controlling_power: raw.controlling_power ?? null,
+    powers: raw.power ?? [],
+    power_state: raw.power_state ?? null,
+    updated_at: raw.updated_at ?? null,
+    factions: (raw.minor_faction_presences ?? []).map((f) => ({
+      name: f.name,
+      government: f.government ?? null,
+      allegiance: f.allegiance ?? null,
+      influence: f.influence ?? null,
+      controlling: f.name === raw.controlling_minor_faction,
+      // Spansh leaves out active_states when a faction has one state.
+      active_states: f.active_states ?? (f.state && f.state !== "None" ? [f.state] : []),
+      pending_states: f.pending_states ?? []
+    })),
+    stations: (raw.stations ?? []).filter((s) => !skipStation(s.type)).map((s) => ({
+      name: s.name,
+      type: s.type ?? null,
+      pad: stationPad(s),
+      arrival_ls: s.distance_to_arrival ?? null
+    })),
+    stars: (raw.bodies ?? []).filter((b) => b.type === "Star").map((b) => ({ name: b.name, arrival_ls: b.distance_to_arrival ?? 0 }))
+  };
+}
+function distanceLy(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+var isAnarchy = (f) => f.government === "Anarchy";
+
+// src/systems/sweep-cache.ts
+var SweepCache = class {
+  constructor(ttlMs = 36e5, now = Date.now, maxSweeps = 4) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+    this.maxSweeps = maxSweeps;
+  }
+  ttlMs;
+  now;
+  maxSweeps;
+  name = "spansh-sweeps";
+  sweeps = [];
+  find(centre, radiusLy) {
+    this.dropExpired();
+    const hit = this.sweeps.find(
+      (s) => distanceLy(s.centre, centre) + radiusLy <= s.coveredLy + 1e-9
+    );
+    return hit?.systems.filter((s) => distanceLy(s.coords, centre) <= radiusLy);
+  }
+  add(centre, radiusLy, systems, key) {
+    const storedAt = key ? this.sweeps.find((s) => s.resume?.key === key)?.storedAt : void 0;
+    if (key) this.sweeps = this.sweeps.filter((s) => s.resume?.key !== key);
+    this.push({ centre, coveredLy: radiusLy, systems, storedAt: storedAt ?? this.now() });
+  }
+  savePartial(p) {
+    const storedAt = this.sweeps.find((s) => s.resume?.key === p.key)?.storedAt ?? this.now();
+    this.sweeps = this.sweeps.filter((s) => s.resume?.key !== p.key);
+    this.push({
+      centre: p.centre,
+      coveredLy: p.coveredLy,
+      systems: p.systems,
+      storedAt,
+      resume: p
+    });
+  }
+  partial(key) {
+    this.dropExpired();
+    return this.sweeps.find((s) => s.resume?.key === key)?.resume;
+  }
+  push(s) {
+    this.sweeps.push(s);
+    while (this.sweeps.length > this.maxSweeps) this.sweeps.shift();
+  }
+  clear() {
+    const n = this.sweeps.length;
+    this.sweeps = [];
+    return n;
+  }
+  stats() {
+    this.dropExpired();
+    const oldest = this.sweeps.length ? Math.min(...this.sweeps.map((s) => s.storedAt)) : void 0;
+    return {
+      name: this.name,
+      entries: this.sweeps.length,
+      oldestAgeSeconds: oldest === void 0 ? null : Math.round((this.now() - oldest) / 1e3)
+    };
+  }
+  dropExpired() {
+    const cutoff = this.now() - this.ttlMs;
+    this.sweeps = this.sweeps.filter((s) => s.storedAt > cutoff);
+  }
+};
+
 // src/spansh/client.ts
-var SERVICE_FILTERS = {
+var TRADER_FILTERS = {
   material_trader_raw: { material_trader: { value: ["Raw"] } },
   material_trader_manufactured: { material_trader: { value: ["Manufactured"] } },
   material_trader_encoded: { material_trader: { value: ["Encoded"] } },
   tech_broker_human: { technology_broker: { value: ["Human"] } },
-  tech_broker_guardian: { technology_broker: { value: ["Guardian"] } },
-  interstellar_factors: { services: [{ name: { value: ["Interstellar Factors Contact"] } }] }
-};
+  tech_broker_guardian: { technology_broker: { value: ["Guardian"] } }
+};
+var NAMED_SERVICES = {
+  interstellar_factors: "Interstellar Factors Contact",
+  black_market: "Black Market",
+  universal_cartographics: "Universal Cartographics",
+  vista_genomics: "Vista Genomics",
+  search_and_rescue: "Search and Rescue",
+  refuel: "Refuel",
+  repair: "Repair",
+  restock: "Restock",
+  shipyard: "Shipyard",
+  outfitting: "Outfitting",
+  market: "Market",
+  apex_interstellar: "Apex Interstellar",
+  frontline_solutions: "Frontline Solutions",
+  pioneer_supplies: "Pioneer Supplies",
+  bartender: "Bartender",
+  refinery_contact: "Refinery Contact",
+  redemption_office: "Redemption Office",
+  crew_lounge: "Crew Lounge",
+  squadron_bank: "Squadron Bank",
+  construction_services: "Construction Services",
+  powerplay: "Powerplay"
+};
+var STATION_SERVICES = [
+  ...Object.keys(TRADER_FILTERS),
+  ...Object.keys(NAMED_SERVICES)
+];
+function serviceFilter(s) {
+  if (Object.hasOwn(TRADER_FILTERS, s)) return TRADER_FILTERS[s];
+  return { services: [{ name: { value: [NAMED_SERVICES[s]] } }] };
+}
 var COUNT_CAP = 1e4;
 var shipKey = (s) => s.toLowerCase().replace(/[\s-]/g, "");
-function pad(s) {
-  if (s.has_large_pad || (s.large_pads ?? 0) > 0) return "L";
-  if ((s.medium_pads ?? 0) > 0) return "M";
-  if ((s.small_pads ?? 0) > 0) return "S";
-  return null;
-}
 var MAX_JOBS = 100;
 var SEARCH_PAGE_SIZE = 50;
+var SWEEP_PAGE_SIZE = 500;
 var CARRIER_TYPE = "Drake-Class Carrier";
 var NON_CARRIER_TYPES = [
   "Asteroid base",
@@ -32131,6 +32325,7 @@ var SpanshClient = class {
     this.now = opts.now ?? Date.now;
     this.systemCache = opts.systemCache ?? cache;
     this.marketCache = opts.marketCache ?? cache;
+    this.sweepCache = opts.sweepCache ?? new SweepCache();
   }
   http;
   cache;
@@ -32141,10 +32336,12 @@ var SpanshClient = class {
   now;
   systemCache;
   marketCache;
+  sweepCache;
   // Job ids by route form, so a call after a timeout collects the job instead of resubmitting.
   routeJobs = /* @__PURE__ */ new Map();
   tradeJobs = /* @__PURE__ */ new Map();
   tradeSubmits = /* @__PURE__ */ new Map();
+  sweeps = /* @__PURE__ */ new Map();
   gate = Promise.resolve();
   lastStart = 0;
   async resolveShip(name) {
@@ -32169,7 +32366,7 @@ var SpanshClient = class {
       shipName = await this.resolveShip(q.ship);
       filters.ships = [{ name: { value: [shipName] } }];
     } else if (q.service) {
-      Object.assign(filters, SERVICE_FILTERS[q.service]);
+      Object.assign(filters, serviceFilter(q.service));
     }
     if (q.largePad) filters.has_large_pad = { value: true };
     if (q.maxDistanceLy !== void 0) filters.distance = { min: 0, max: q.maxDistanceLy };
@@ -32236,7 +32433,7 @@ var SpanshClient = class {
         name: s.name,
         type: s.type ?? null,
         arrival_ls: s.distance_to_arrival ?? null,
-        pad: pad(s),
+        pad: stationPad(s),
         market: s.has_market ?? false,
         market_id: s.market_id ?? null,
         outfitting: s.has_outfitting ?? false,
@@ -32253,6 +32450,78 @@ var SpanshClient = class {
     );
     return detail.record.needs_permit ?? null;
   }
+  /** Populated systems within radiusLy of near. Stops paging at opts.deadline; a partial result is cached and the next call resumes it. */
+  async populatedSystems(near, radiusLy, opts = {}) {
+    const centre = (await this.system(near, 0)).coords;
+    const cached2 = this.sweepCache.find(centre, radiusLy);
+    if (cached2)
+      return { centre, systems: cached2, total: cached2.length, partial: false, coveredLy: radiusLy };
+    const key = `${near.toLowerCase()}:${radiusLy}`;
+    let running = this.sweeps.get(key);
+    if (!running) {
+      running = this.sweepPages(near, radiusLy, centre, key, opts).finally(
+        () => this.sweeps.delete(key)
+      );
+      this.sweeps.set(key, running);
+    }
+    return running;
+  }
+  async sweepPages(near, radiusLy, centre, key, opts) {
+    const resume = this.sweepCache.partial(key);
+    const systems = resume ? [...resume.systems] : [];
+    const seen = new Set(systems.map((s) => s.id64));
+    let total = resume?.total ?? 0;
+    let partial2 = false;
+    for (let page2 = 0; ; page2++) {
+      if (page2 > 0 && opts.deadline !== void 0 && this.now() >= opts.deadline) {
+        partial2 = true;
+        break;
+      }
+      const body = {
+        filters: {
+          // Resuming by distance, not page: Spansh's list can shift between calls an hour apart.
+          distance: { min: resume?.coveredLy ?? 0, max: radiusLy },
+          population: { comparison: "<=>", value: [1, 1e11] }
+        },
+        sort: [{ distance: { direction: "asc" } }],
+        size: SWEEP_PAGE_SIZE,
+        page: page2,
+        reference_system: near
+      };
+      let res;
+      try {
+        res = await this.post("/systems/search", JSON.stringify(body), "application/json");
+      } catch (err) {
+        if (err instanceof SpanshError && err.status === 400) {
+          throw new UserError(
+            `Spansh rejected the search (${err.detail}). Check that "${near}" is an exact system name (spansh_system).`
+          );
+        }
+        throw err;
+      }
+      if (!resume) total = res.count;
+      const results = res.results ?? [];
+      for (const raw of results) {
+        const s = mapSystem(raw);
+        if (s && !seen.has(s.id64)) {
+          seen.add(s.id64);
+          systems.push(s);
+        }
+      }
+      if (results.length < SWEEP_PAGE_SIZE) break;
+    }
+    if (!partial2) {
+      this.sweepCache.add(centre, radiusLy, systems, key);
+      return { centre, systems, total, partial: partial2, coveredLy: radiusLy };
+    }
+    const last = systems[systems.length - 1];
+    const coveredLy = Math.max(
+      resume?.coveredLy ?? 0,
+      last ? distanceLy(last.coords, centre) - 0.01 : 0
+    );
+    this.sweepCache.savePartial({ key, centre, coveredLy, systems, total });
+    return { centre, systems, total, partial: partial2, coveredLy };
+  }
   async route(q, opts = {}) {
     const form = new URLSearchParams({
       from: q.from,
@@ -32548,7 +32817,7 @@ var SpanshClient = class {
       distance_ly: s.distance ?? null,
       arrival_ls: s.distance_to_arrival ?? null,
       coords: { x, y, z: z2 },
-      pad: pad(s),
+      pad: stationPad(s),
       type: s.type ?? null,
       planetary: s.is_planetary ?? false,
       market_age_hours: Number.isNaN(updated) ? null : Math.round((now - updated) / 36e5 * 10) / 10,
@@ -32579,7 +32848,7 @@ var SpanshClient = class {
       distance_ly: s.distance ?? 0,
       arrival_ls: s.distance_to_arrival ?? null,
       type: s.type ?? null,
-      pad: pad(s),
+      pad: stationPad(s),
       planetary: s.is_planetary ?? null,
       price,
       market_updated_at: s.market_updated_at ?? null,
@@ -34610,9 +34879,12 @@ function buildDeps(config2, opts = {}) {
   caches.register(spanshSystemCache);
   const spanshMarketCache = new TtlCache("spansh-markets", 6e5);
   caches.register(spanshMarketCache);
+  const spanshSweepCache = new SweepCache();
+  caches.register(spanshSweepCache);
   const spansh = new SpanshClient(http, spanshCache, {
     systemCache: spanshSystemCache,
-    marketCache: spanshMarketCache
+    marketCache: spanshMarketCache,
+    sweepCache: spanshSweepCache
   });
   const capiHttp = new HttpClient({ userAgent: `EDCD-EdMcp-${VERSION}`, fetchFn: opts.fetchFn });
   const capiCache = new TtlCache("capi", 6e4);
@@ -41918,6 +42190,15 @@ var McpServer = class {
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
     this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
+    if (options?.capabilities?.tools) {
+      this.setToolRequestHandlers();
+    }
+    if (options?.capabilities?.resources) {
+      this.setResourceRequestHandlers();
+    }
+    if (options?.capabilities?.prompts) {
+      this.setPromptRequestHandlers();
+    }
   }
   /**
    * Access experimental features.
@@ -43245,10 +43526,10 @@ function slotInfo(hull, slot, item) {
   return { slot, kind: kind2, size };
 }
 function bulkheadFromItem(hull, item) {
-  const lower = item.toLowerCase();
+  const lower2 = item.toLowerCase();
   const offset = hull.bulkheads.length > 5 ? 1 : 0;
-  if (lower.endsWith("_armour_grade1_default")) return hull.bulkheads[0] ?? null;
-  const i = BULKHEAD_SUFFIXES.findIndex((s) => lower.endsWith(`_armour_${s}`));
+  if (lower2.endsWith("_armour_grade1_default")) return hull.bulkheads[0] ?? null;
+  const i = BULKHEAD_SUFFIXES.findIndex((s) => lower2.endsWith(`_armour_${s}`));
   return i < 0 ? null : hull.bulkheads[i + offset] ?? null;
 }
 function bulkheadItem(hull, module) {
@@ -44712,13 +44993,13 @@ function resolveRules(stored, override, usePreferences, auto, jumpAuto = { ly: n
   const prefs = applyPatch(usePreferences ? stored : OFF_PREFS, override ?? {});
   const p = prefs.stations.min_pad;
   const fromRequest = override?.stations?.min_pad !== void 0;
-  const pad2 = p === "auto" ? auto : p === "none" ? { size: null, source: fromRequest ? "request" : "none" } : { size: p, source: fromRequest ? "request" : "preferences" };
+  const pad = p === "auto" ? auto : p === "none" ? { size: null, source: fromRequest ? "request" : "none" } : { size: p, source: fromRequest ? "request" : "preferences" };
   const range = prefs.travel.jump_range_ly;
   const fromRequestRange = override?.travel?.jump_range_ly !== void 0;
   const { ly, source } = range !== "auto" ? { ly: range, source: fromRequestRange ? "request" : "preferences" } : jumpAuto.ly ? { ly: jumpAuto.ly, source: jumpAuto.source } : { ly: 30, source: "auto: default 30 LY" };
   return {
     prefs,
-    pad: pad2,
+    pad,
     travel: { ...prefs.travel, jump_range_ly: ly },
     jumpRangeSource: source
   };
@@ -45092,11 +45373,11 @@ function union2(a, b) {
 async function resolveSearchRules(deps, preferences, usePreferences, largePad) {
   const stored = deps.prefs && usePreferences ? await deps.prefs.get() : DEFAULT_PREFS;
   const override = largePad ? { ...preferences, stations: { ...preferences?.stations, min_pad: "L" } } : preferences ?? {};
-  let pad2 = { size: null, source: "none" };
+  let pad = { size: null, source: "none" };
   let jump2;
-  const first = resolveRules(stored, override, usePreferences, pad2);
+  const first = resolveRules(stored, override, usePreferences, pad);
   if (first.prefs.stations.min_pad === "auto") {
-    pad2 = await autoPad(deps.currentShip ?? (async () => null));
+    pad = await autoPad(deps.currentShip ?? (async () => null));
   }
   if (first.prefs.travel.jump_range_ly === "auto") {
     const max = await deps.jumpRange?.().catch(() => null);
@@ -45108,7 +45389,7 @@ async function resolveSearchRules(deps, preferences, usePreferences, largePad) {
       };
     }
   }
-  return resolveRules(stored, override, usePreferences, pad2, jump2);
+  return resolveRules(stored, override, usePreferences, pad, jump2);
 }
 
 // src/tools/materials.ts
@@ -45299,7 +45580,7 @@ function legBetween(from, to, travel) {
   if (same(from.system, to.system) && same(from.station, to.station)) {
     return { jumps: 0, seconds: 0, distanceLy: 0 };
   }
-  const distanceLy = same(from.system, to.system) ? 0 : Math.hypot(
+  const distanceLy2 = same(from.system, to.system) ? 0 : Math.hypot(
     from.coords.x - to.coords.x,
     from.coords.y - to.coords.y,
     from.coords.z - to.coords.z
@@ -45307,14 +45588,14 @@ function legBetween(from, to, travel) {
   return {
     ...legSeconds(
       {
-        distanceLy,
+        distanceLy: distanceLy2,
         arrivalLs: to.arrivalLs,
         planetary: to.planetary,
         stationKnown: to.station !== null
       },
       travel
     ),
-    distanceLy
+    distanceLy: distanceLy2
   };
 }
 
@@ -46369,6 +46650,343 @@ function registerLoopTools(server, deps) {
   }
 }
 
+// src/systems/massacre.ts
+var SOURCE_RANGE_LY = 10;
+var NO_MASSACRES = /* @__PURE__ */ new Set(["war", "civil war", "election"]);
+function massacreTargets(systems, centre, opts) {
+  const pirates = systems.flatMap(
+    (s) => s.factions.filter(isAnarchy).map((f) => ({ faction: f.name, system: s }))
+  );
+  const piratesNear = /* @__PURE__ */ new Map();
+  const piratesInRange = (s) => {
+    let list2 = piratesNear.get(s.id64);
+    if (!list2) {
+      list2 = pirates.filter((p) => p.system.id64 !== s.id64).filter((p) => distanceLy(p.system.coords, s.coords) <= SOURCE_RANGE_LY).map((p) => ({ faction: p.faction, system: p.system.name }));
+      piratesNear.set(s.id64, list2);
+    }
+    return list2;
+  };
+  const candidates = systems.filter((s) => s.stations.length > 0);
+  const targets = [];
+  let leftOutSpread = 0;
+  for (const p of pirates) {
+    const distance2 = distanceLy(p.system.coords, centre);
+    if (distance2 > opts.radiusLy) continue;
+    const spreadLs = Math.max(0, ...p.system.stars.map((s) => s.arrival_ls));
+    if (spreadLs > opts.maxStarLs) {
+      leftOutSpread++;
+      continue;
+    }
+    const sources = [];
+    const excluded = [];
+    for (const s of candidates) {
+      if (s.id64 === p.system.id64) continue;
+      const toTarget = distanceLy(s.coords, p.system.coords);
+      if (toTarget > SOURCE_RANGE_LY) continue;
+      const blocked = s.factions.flatMap(
+        (f) => f.active_states.filter((x) => NO_MASSACRES.has(x.toLowerCase())).map((state) => ({ system: s.name, faction: f.name, state, updated_at: s.updated_at }))
+      );
+      if (blocked.length) {
+        excluded.push(...blocked);
+        continue;
+      }
+      const others = piratesInRange(s).filter((x) => x.faction !== p.faction);
+      sources.push({
+        system: s,
+        distanceToTargetLy: toTarget,
+        primary: others.length === 0,
+        otherPirates: others
+      });
+    }
+    const primary = sources.filter((s) => s.primary);
+    if (!primary.length) continue;
+    const givers = new Set(
+      primary.flatMap((s) => s.system.factions.filter((f) => !isAnarchy(f)).map((f) => f.name))
+    );
+    if (givers.size === 0) continue;
+    sources.sort(
+      (a, b) => Number(b.primary) - Number(a.primary) || a.distanceToTargetLy - b.distanceToTargetLy
+    );
+    targets.push({
+      faction: p.faction,
+      system: p.system,
+      distanceLy: distance2,
+      spreadLs,
+      stackSize: givers.size,
+      sources,
+      excluded
+    });
+  }
+  targets.sort(
+    (a, b) => b.stackSize - a.stackSize || a.spreadLs - b.spreadLs || a.distanceLy - b.distanceLy
+  );
+  return { targets, leftOutSpread };
+}
+
+// src/systems/state.ts
+var lower = (xs) => xs?.length ? new Set(xs.map((x) => x.toLowerCase())) : null;
+var has = (set2, v) => !set2 || v !== null && set2.has(v.toLowerCase());
+function hasFilter(q) {
+  return [q.states, q.government, q.allegiance, q.power, q.security].some((x) => x?.length);
+}
+function systemsByState(systems, centre, radiusLy, q) {
+  const states = lower(q.states);
+  const government = lower(q.government);
+  const allegiance = lower(q.allegiance);
+  const power2 = lower(q.power);
+  const security = lower(q.security);
+  const out = [];
+  for (const s of systems) {
+    const d = distanceLy(s.coords, centre);
+    if (d > radiusLy) continue;
+    if (!has(government, s.government) || !has(allegiance, s.allegiance)) continue;
+    if (!has(power2, s.controlling_power) || !has(security, s.security)) continue;
+    let factions = [];
+    if (states) {
+      factions = s.factions.filter(
+        (f) => (!q.controllingOnly || f.controlling) && [...f.active_states, ...q.includePending ? f.pending_states : []].some(
+          (x) => states.has(x.toLowerCase())
+        )
+      );
+      if (!factions.length) continue;
+    }
+    out.push({ system: s, distanceLy: d, factions });
+  }
+  return out.sort((a, b) => a.distanceLy - b.distanceLy);
+}
+
+// src/tools/systems.ts
+var TIME_LIMIT_MS2 = 2e4;
+var MASSACRE_MARGIN_LY = 2 * SOURCE_RANGE_LY;
+var partialNote = (coveredLy) => `Spansh returned systems out to ${Math.floor(coveredLy * 10) / 10} ly within the time limit. Call again to continue the search.`;
+var STALE_HOURS = 72;
+var FAR_STAR_LS = 1e3;
+var Radius = external_exports.number().min(1).max(50).default(50);
+var Limit = external_exports.number().int().min(1).max(100).default(50);
+var Values = external_exports.array(external_exports.string()).optional();
+function registerSystemTools(server, deps) {
+  const now = deps.now ?? Date.now;
+  const resolveNear = async (near, notes) => {
+    if (near) return near;
+    if (deps.journal) {
+      try {
+        const system = (await deps.journal.state())?.location.system;
+        if (system) return system;
+      } catch (err) {
+        notes.push(`Journal unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    const why = notes.length ? ` (${notes.join(" ")})` : "";
+    throw new UserError(`Give near, or set up the journal to use the current system${why}.`);
+  };
+  const ageHours2 = (s) => s.updated_at ? Math.round((now() - Date.parse(s.updated_at)) / 36e5 * 10) / 10 : null;
+  const leg = (ly, t) => legSeconds({ distanceLy: ly, arrivalLs: null, planetary: false, stationKnown: false }, t);
+  const nearestWith = (s, ok2) => {
+    const ls = s.stations.filter((x) => ok2(x.pad)).map((x) => x.arrival_ls ?? Infinity);
+    const min3 = Math.min(...ls);
+    return Number.isFinite(min3) ? Math.round(min3) : null;
+  };
+  const pads = (s) => ({
+    L: nearestWith(s, (p) => p === "L"),
+    M: nearestWith(s, (p) => p === "L" || p === "M"),
+    S: nearestWith(s, (p) => p !== null)
+  });
+  server.registerTool(
+    "systems_by_state",
+    {
+      annotations: {
+        title: "Systems by Faction State",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      description: "Find the nearest populated systems with a faction in a given state (e.g. War, Civil War, Election, Boom, Outbreak), or by government, allegiance, controlling power or security. near defaults to the journal location. War and Civil War results say conflict_zones: likely (settlements are not checked). Faction states come from player visits: check age_hours. Uses one Spansh search of all populated systems in radius_ly, cached for an hour; the first call can take 10 s.",
+      inputSchema: {
+        near: external_exports.string().optional().describe("Exact reference system name"),
+        radius_ly: Radius,
+        state: Values.describe("Faction states to match, e.g. ['War', 'Civil War']"),
+        include_pending: external_exports.boolean().default(false),
+        controlling_only: external_exports.boolean().default(false),
+        government: Values,
+        allegiance: Values,
+        power: Values.describe("Controlling power"),
+        security: Values,
+        limit: Limit
+      }
+    },
+    wrap(
+      async (a) => {
+        const q = {
+          states: a.state,
+          includePending: a.include_pending,
+          controllingOnly: a.controlling_only,
+          government: a.government,
+          allegiance: a.allegiance,
+          power: a.power,
+          security: a.security
+        };
+        if (!hasFilter(q)) {
+          throw new UserError(
+            "Give at least one of state, government, allegiance, power or security."
+          );
+        }
+        if (a.controlling_only && !a.state?.length) {
+          throw new UserError(
+            "controlling_only needs state: it limits the state match to the controlling faction."
+          );
+        }
+        const notes = [];
+        const near = await resolveNear(a.near, notes);
+        const rules = await resolveSearchRules(deps, void 0, true);
+        const sweep = await deps.spansh.populatedSystems(near, a.radius_ly, {
+          deadline: now() + TIME_LIMIT_MS2
+        });
+        const matches2 = systemsByState(
+          sweep.systems,
+          sweep.centre,
+          Math.min(a.radius_ly, sweep.coveredLy),
+          q
+        );
+        const shown = matches2.slice(0, a.limit);
+        const stale = shown.filter((m) => (ageHours2(m.system) ?? 0) > STALE_HOURS).length;
+        if (stale) notes.push(`${stale} results have data more than ${STALE_HOURS / 24} days old.`);
+        if (sweep.partial) {
+          notes.push(partialNote(sweep.coveredLy));
+        }
+        return {
+          near,
+          searched: sweep.systems.length,
+          travel: describeRules(rules).travel,
+          total_matches: matches2.length,
+          partial: sweep.partial,
+          ...sweep.partial ? { covered_ly: Math.floor(sweep.coveredLy * 10) / 10 } : {},
+          systems: shown.map((m) => {
+            const s = m.system;
+            const war = m.factions.some(
+              (f) => f.active_states.some((x) => /^(war|civil war)$/i.test(x))
+            );
+            const nearest3 = pads(s);
+            const bestPad = nearest3.L !== null ? "L" : nearest3.M !== null ? "M" : nearest3.S !== null ? "S" : null;
+            return {
+              system: s.name,
+              distance_ly: Math.round(m.distanceLy * 100) / 100,
+              jumps: leg(m.distanceLy, rules.travel).jumps,
+              matching_factions: m.factions.map((f) => ({
+                name: f.name,
+                controlling: f.controlling,
+                influence: f.influence,
+                active_states: f.active_states,
+                pending_states: f.pending_states
+              })),
+              government: s.government,
+              allegiance: s.allegiance,
+              security: s.security,
+              controlling_power: s.controlling_power,
+              power_state: s.power_state,
+              best_pad: bestPad,
+              nearest_station_ls: bestPad ? nearest3[bestPad] : null,
+              updated_at: s.updated_at,
+              age_hours: ageHours2(s),
+              ...war ? { conflict_zones: "likely" } : {}
+            };
+          }),
+          notes
+        };
+      }
+    )
+  );
+  server.registerTool(
+    "massacre_targets",
+    {
+      annotations: {
+        title: "Find Massacre Targets",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      description: "Find pirate (Anarchy) factions near you with good sources of stackable pirate massacre missions, as Inara's 'nearest massacre missions' does. Sources are populated systems within 10 ly of the target; a primary source has no other pirate faction in other systems within 10 ly (its own pirate faction does not count, as missions send you to another system), so all its massacre missions are for this target. Sources with a faction in War, Civil War or Election are excluded and listed. stack_size is the number of distinct giving factions in the primary sources. Targets whose farthest star is beyond max_star_ls (default 10,000) are left out, because fights there can be far from the arrival star. Ranked by stack_size, then spread_ls, then distance. Results are candidates: mission boards are not published. Pads are listed, not filtered. near defaults to the journal location.",
+      inputSchema: {
+        near: external_exports.string().optional().describe("Exact reference system name"),
+        radius_ly: Radius.describe("Targets within this distance"),
+        max_star_ls: external_exports.number().min(0).default(1e4),
+        limit: Limit,
+        preferences: PrefsPatchSchema.optional(),
+        use_preferences: external_exports.boolean().default(true)
+      }
+    },
+    wrap(
+      async (a) => {
+        const notes = [];
+        const near = await resolveNear(a.near, notes);
+        const rules = await resolveSearchRules(deps, a.preferences, a.use_preferences);
+        const sweep = await deps.spansh.populatedSystems(near, a.radius_ly + MASSACRE_MARGIN_LY, {
+          deadline: now() + TIME_LIMIT_MS2
+        });
+        const { targets, leftOutSpread } = massacreTargets(sweep.systems, sweep.centre, {
+          // Past covered_ly - margin a source could have a pirate neighbour that was not fetched.
+          // A negative radius lists nothing, not even a target at distance 0.
+          radiusLy: sweep.partial ? Math.min(a.radius_ly, sweep.coveredLy - MASSACRE_MARGIN_LY) : a.radius_ly,
+          maxStarLs: a.max_star_ls
+        });
+        notes.push(
+          "These are candidates: whether the mission boards have massacre missions now depends on recent player activity."
+        );
+        if (leftOutSpread) {
+          notes.push(
+            `${leftOutSpread} targets left out: a star beyond ${a.max_star_ls} ls. Raise max_star_ls to see them.`
+          );
+        }
+        if (sweep.partial) {
+          notes.push(partialNote(sweep.coveredLy));
+        }
+        return {
+          near,
+          searched: sweep.systems.length,
+          left_out_spread: leftOutSpread,
+          partial: sweep.partial,
+          ...sweep.partial ? { covered_ly: Math.floor(sweep.coveredLy * 10) / 10 } : {},
+          travel: describeRules(rules).travel,
+          targets: targets.slice(0, a.limit).map((t) => ({
+            target_faction: t.faction,
+            target_system: t.system.name,
+            distance_ly: Math.round(t.distanceLy * 100) / 100,
+            travel_min: Math.round(leg(t.distanceLy, rules.travel).seconds / 6) / 10,
+            stack_size: t.stackSize,
+            spread_ls: Math.round(t.spreadLs),
+            far_stars: t.system.stars.filter((s) => s.arrival_ls > FAR_STAR_LS).map((s) => ({ name: s.name, arrival_ls: Math.round(s.arrival_ls) })),
+            sources: t.sources.map((s) => {
+              const counts2 = { federation: 0, empire: 0, alliance: 0, independent: 0 };
+              for (const f of s.system.factions) {
+                const k = f.allegiance?.toLowerCase();
+                if (!isAnarchy(f) && k && k in counts2) counts2[k]++;
+              }
+              return {
+                system: s.system.name,
+                primary: s.primary,
+                other_pirates: s.otherPirates,
+                distance_to_target_ly: Math.round(s.distanceToTargetLy * 100) / 100,
+                allegiance_counts: counts2,
+                pads: pads(s.system),
+                factions: s.system.factions.map((f) => ({
+                  name: f.name,
+                  allegiance: f.allegiance,
+                  active_states: f.active_states
+                })),
+                updated_at: s.system.updated_at,
+                age_hours: ageHours2(s.system)
+              };
+            }),
+            excluded: t.excluded
+          })),
+          notes
+        };
+      }
+    )
+  );
+}
+
 // src/tools/inara.ts
 function registerInaraTools(server, deps) {
   server.registerTool(
@@ -47541,15 +48159,8 @@ function registerStationTools(server, deps) {
 }
 
 // src/tools/spansh.ts
-var Service = external_exports.enum([
-  "material_trader_raw",
-  "material_trader_manufactured",
-  "material_trader_encoded",
-  "tech_broker_human",
-  "tech_broker_guardian",
-  "interstellar_factors"
-]);
-var Limit = external_exports.number().int().min(1).max(50).default(10);
+var Service = external_exports.enum(STATION_SERVICES);
+var Limit2 = external_exports.number().int().min(1).max(50).default(10);
 function registerSpanshTools(server, deps) {
   const { spansh } = deps;
   const now = deps.now ?? Date.now;
@@ -47563,7 +48174,7 @@ function registerSpanshTools(server, deps) {
         idempotentHint: true,
         openWorldHint: true
       },
-      description: "Find the best stations near a system, ranked by travel time and cost, that sell a module or ship, or offer a service (material trader, tech broker, interstellar factors). Give exactly one of module, ship, service. Module names are generic (e.g. 'Frame Shift Drive') with class 1-8 and rating A-I; give class and rating to compare prices. Applies the commander's stored travel preferences (arrival distance, station types, pad size from the current ship, travel-time model); override any of them for this call with `preferences` (same shape as prefs_set's patch) or ignore them with use_preferences=false. Returns total (Spansh matches before preferences; 10000 means 10000 or more), matched (matches after preferences among the stations fetched: the nearest 50, or up to 100 when the arrival limit was relaxed). Stations are ranked by estimated travel time (jumps plus supercruise, docking and planetary time) and, for purchases, by effective cost = price + travel time \xD7 the commander's credits_per_hour. Each station has jumps, travel_s, travel_min, arrival_assumed, effective_cost and discount_pct (versus the median price); recommended explains the trade-off. Stations in permit-locked systems are left out unless permit_systems is allow, which keeps them with needs_permit: true. Also returns any relaxed rules, the applied preferences and notes. Cached 5 min.",
+      description: "Find the best stations near a system, ranked by travel time and cost, that sell a module or ship, or offer a service: material traders, tech brokers, interstellar factors, black market, Universal Cartographics, Vista Genomics, Search and Rescue, refuel, repair, restock, shipyard, outfitting, market and more (see the service enum). Give exactly one of module, ship, service. Module names are generic (e.g. 'Frame Shift Drive') with class 1-8 and rating A-I; give class and rating to compare prices. Applies the commander's stored travel preferences (arrival distance, station types, pad size from the current ship, travel-time model); override any of them for this call with `preferences` (same shape as prefs_set's patch) or ignore them with use_preferences=false. Returns total (Spansh matches before preferences; 10000 means 10000 or more), matched (matches after preferences among the stations fetched: the nearest 50, or up to 100 when the arrival limit was relaxed). Stations are ranked by estimated travel time (jumps plus supercruise, docking and planetary time) and, for purchases, by effective cost = price + travel time \xD7 the commander's credits_per_hour. Each station has jumps, travel_s, travel_min, arrival_assumed, effective_cost and discount_pct (versus the median price); recommended explains the trade-off. Stations in permit-locked systems are left out unless permit_systems is allow, which keeps them with needs_permit: true. Also returns any relaxed rules, the applied preferences and notes. Cached 5 min.",
       inputSchema: {
         near: external_exports.string().describe("Exact reference system name"),
         module: external_exports.object({
@@ -47577,7 +48188,7 @@ function registerSpanshTools(server, deps) {
         max_distance_ly: external_exports.number().positive().optional(),
         preferences: PrefsPatchSchema.optional(),
         use_preferences: external_exports.boolean().default(true),
-        limit: Limit
+        limit: Limit2
       }
     },
     wrap(
@@ -47611,7 +48222,7 @@ function registerSpanshTools(server, deps) {
         openWorldHint: true
       },
       description: "Look up a system by exact name: coordinates, allegiance, permit, and its stations sorted by distance from arrival (limit applies to stations). Cached 24 h.",
-      inputSchema: { name: external_exports.string(), limit: Limit }
+      inputSchema: { name: external_exports.string(), limit: Limit2 }
     },
     wrap(async (a) => spansh.system(a.name, a.limit))
   );
@@ -48230,6 +48841,13 @@ function createServer3(deps) {
       currentShip: deps.currentShip,
       jumpRange: deps.jumpRange
     });
+    registerSystemTools(server, {
+      spansh: deps.spansh,
+      journal: deps.journal,
+      prefs: deps.prefs,
+      currentShip: deps.currentShip,
+      jumpRange: deps.jumpRange
+    });
   }
   if (deps.catalog && deps.spansh) {
     registerMaterialsTools(server, {