ed-mcp 0.5.0 → 0.5.1

package/dist/index.js

@@ -28752,7 +28752,7 @@ async function canonical(p) {
 }
 
 // src/version.ts
-var VERSION = "0.5.0";
+var VERSION = "0.5.1";
 
 // src/config.ts
 var ConfigError = class extends Error {
@@ -32201,12 +32201,32 @@ var SweepCache = class {
   find(centre, radiusLy) {
     this.dropExpired();
     const hit = this.sweeps.find(
-      (s) => distanceLy(s.centre, centre) + radiusLy <= s.radiusLy + 1e-9
+      (s) => distanceLy(s.centre, centre) + radiusLy <= s.coveredLy + 1e-9
     );
     return hit?.systems.filter((s) => distanceLy(s.coords, centre) <= radiusLy);
   }
-  add(centre, radiusLy, systems) {
-    this.sweeps.push({ centre, radiusLy, systems, storedAt: this.now() });
+  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() {
@@ -32216,7 +32236,7 @@ var SweepCache = class {
   }
   stats() {
     this.dropExpired();
-    const oldest = this.sweeps[0]?.storedAt;
+    const oldest = this.sweeps.length ? Math.min(...this.sweeps.map((s) => s.storedAt)) : void 0;
     return {
       name: this.name,
       entries: this.sweeps.length,
@@ -32430,25 +32450,27 @@ var SpanshClient = class {
     );
     return detail.record.needs_permit ?? null;
   }
-  /** Populated systems within radiusLy of near. Stops paging at opts.deadline; a partial result is not cached. */
+  /** 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 };
+    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, opts).finally(
+      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, opts) {
-    const systems = [];
-    const seen = /* @__PURE__ */ new Set();
-    let total = 0;
+  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) {
@@ -32457,7 +32479,8 @@ var SpanshClient = class {
       }
       const body = {
         filters: {
-          distance: { min: 0, max: radiusLy },
+          // 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" } }],
@@ -32476,7 +32499,7 @@ var SpanshClient = class {
         }
         throw err;
       }
-      total = res.count;
+      if (!resume) total = res.count;
       const results = res.results ?? [];
       for (const raw of results) {
         const s = mapSystem(raw);
@@ -32487,8 +32510,17 @@ var SpanshClient = class {
       }
       if (results.length < SWEEP_PAGE_SIZE) break;
     }
-    if (!partial2) this.sweepCache.add(centre, radiusLy, systems);
-    return { centre, systems, total, partial: partial2 };
+    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({
@@ -46726,6 +46758,7 @@ function systemsByState(systems, centre, radiusLy, q) {
 // 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);
@@ -46809,12 +46842,17 @@ function registerSystemTools(server, deps) {
         const sweep = await deps.spansh.populatedSystems(near, a.radius_ly, {
           deadline: now() + TIME_LIMIT_MS2
         });
-        const matches2 = systemsByState(sweep.systems, sweep.centre, a.radius_ly, q);
+        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("Spansh did not return every system in time; results may be missing.");
+          notes.push(partialNote(sweep.coveredLy));
         }
         return {
           near,
@@ -46822,6 +46860,7 @@ function registerSystemTools(server, deps) {
           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(
@@ -46886,7 +46925,9 @@ function registerSystemTools(server, deps) {
           deadline: now() + TIME_LIMIT_MS2
         });
         const { targets, leftOutSpread } = massacreTargets(sweep.systems, sweep.centre, {
-          radiusLy: a.radius_ly,
+          // 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(
@@ -46898,15 +46939,14 @@ function registerSystemTools(server, deps) {
           );
         }
         if (sweep.partial) {
-          notes.push(
-            "Spansh did not return every system in time: a source can look primary when a pirate faction near the edge was missed."
-          );
+          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,