@myclaw163/clawclaw-cli 0.6.54

package/src/strategies/loader.ts

@@ -0,0 +1,172 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, mkdtempSync, writeFileSync, rmSync } from 'fs';
+import { dirname, join, resolve, basename } from 'path';
+import { tmpdir } from 'os';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { getWorkspaceDir } from '../lib/init-command.js';
+import type { Plugin, OnResolveArgs } from 'esbuild';
+import type { Strategy, StrategyEntry } from './types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Resolve SDK path for user strategy imports (raw filesystem path, not URL).
+// realpathSync ensures dedup against built-in strategies even under --preserve-symlinks.
+const SDK_PATH = realpathSync(resolve(__dirname, '../sdk/index.ts'));
+
+const strategyMap = new Map<string, StrategyEntry>();
+const knowledgeDocMap = new Map<string, string>();
+let loaded = false;
+
+const INFRA_FILES = new Set(['loader', 'types', 'game-utils', 'player-targets', 'greeting', 'spawn', 'strategy-loop', 'new-events-backfill']);
+
+function resolveUserStrategiesDir(): string | undefined {
+  const workspaceDir = getWorkspaceDir();
+  if (!existsSync(workspaceDir)) return undefined;
+  const strategiesDir = join(workspaceDir, 'strategies');
+  if (!existsSync(strategiesDir)) return undefined;
+  return strategiesDir;
+}
+
+/**
+ * Create an esbuild plugin that intercepts `@myclaw163/clawclaw-cli` and
+ * `@myclaw163/clawclaw-cli/*` imports (and the legacy bare `clawclaw-cli`
+ * name for backward compat) and redirects them to the local SDK path
+ * (marked external so Node resolves the same module instance at runtime).
+ *
+ * `require()` calls fail the build with a clear error, since `require` is
+ * unavailable in ESM output and would otherwise crash at runtime.
+ */
+function createSdkPlugin(): { plugin: Plugin } {
+  const sdkUrl = pathToFileURL(SDK_PATH).href;
+
+  const plugin: Plugin = {
+    name: 'clawclaw-cli-sdk',
+    setup(build) {
+      build.onResolve({ filter: /^(?:@myclaw163\/)?clawclaw-cli(?:\/.*)?$/ }, (args: OnResolveArgs) => {
+        if (args.kind === 'require-call') {
+          return {
+            errors: [{
+              text: `require('${args.path}') is not supported in user strategies. Use static imports: import { ... } from '${args.path}'.`,
+            }],
+          };
+        }
+        return { path: sdkUrl, external: true };
+      });
+    },
+  };
+
+  return { plugin };
+}
+
+// Returns Record<string, unknown> — slightly less precise than native import()'s
+// Module type, but both are cast to StrategyEntry via `as` in loadFromDir.
+export async function importUserFile(filePath: string): Promise<Record<string, unknown>> {
+  const { plugin } = createSdkPlugin();
+  const { build } = await import('esbuild');
+  const result = await build({
+    stdin: {
+      contents: readFileSync(filePath, 'utf8'),
+      resolveDir: dirname(filePath),
+      sourcefile: basename(filePath),
+      loader: filePath.endsWith('.ts') ? 'ts' : 'js',
+    },
+    bundle: true,
+    format: 'esm',
+    write: false,
+    platform: 'node',
+    packages: 'external',
+    plugins: [plugin],
+  });
+
+  // Write to temporary file so Node's module cache deduplicates the SDK —
+  // data URLs load as separate module instances, breaking instanceof checks.
+  const tmpDir = mkdtempSync(join(tmpdir(), 'ccl-strategy-'));
+  const tmpFile = join(tmpDir, basename(filePath).replace(/\.(ts|js)$/, '.mjs'));
+  try {
+    writeFileSync(tmpFile, result.outputFiles[0].text);
+    return await import(pathToFileURL(tmpFile).href);
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+async function loadFromDir(dir: string, skipInfra: boolean): Promise<void> {
+  let files: string[];
+  try {
+    files = readdirSync(dir).filter(f => {
+      if (f.startsWith('_')) return false;
+      const match = f.match(/^(.+)\.(ts|js)$/);
+      if (!match) return false;
+      if (match[1].endsWith('.d')) return false;
+      if (match[1].endsWith('.test')) return false;
+      return !skipInfra || !INFRA_FILES.has(match[1]);
+    });
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    try {
+      const filePath = realpathSync(join(dir, file));
+      const mod = skipInfra
+        ? await import(pathToFileURL(filePath).href)
+        : await importUserFile(filePath);
+      const entry: StrategyEntry | undefined = mod.strategy as StrategyEntry | undefined;
+      if (entry?.id && typeof entry.description === 'string' && typeof entry.create === 'function') {
+        strategyMap.set(entry.id, entry);
+        const sidecar = filePath.replace(/\.(ts|js)$/, '.knowledge.md');
+        if (existsSync(sidecar)) knowledgeDocMap.set(entry.id, sidecar);
+      }
+    } catch (err) {
+      if (!skipInfra) {
+        // Strip temp-dir paths from error messages — they leak internal
+        // implementation details (e.g., /tmp/ccl-strategy-XXXX/strategy.mjs)
+        const raw = err instanceof Error ? err.message : String(err);
+        const cleaned = raw.replace(/\S*ccl-strategy-[^/]*\//g, '');
+        console.error(`[ccl] Failed to load user strategy ${file}: ${cleaned}`);
+      }
+    }
+  }
+}
+
+async function ensureLoaded(): Promise<void> {
+  if (loaded) return;
+  loaded = true;
+  await loadFromDir(__dirname, true);
+  const userDir = resolveUserStrategiesDir();
+  if (userDir) await loadFromDir(userDir, false);
+}
+
+export async function getStrategyEntry(id: string): Promise<StrategyEntry | undefined> {
+  await ensureLoaded();
+  return strategyMap.get(id);
+}
+
+export async function listStrategyEntries(): Promise<StrategyEntry[]> {
+  await ensureLoaded();
+  return [...strategyMap.values()];
+}
+
+export async function getStrategyKnowledgeDoc(id: string): Promise<string | undefined> {
+  await ensureLoaded();
+  const path = knowledgeDocMap.get(id);
+  if (!path || !existsSync(path)) return undefined;
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return undefined;
+  }
+}
+
+export async function resolveStrategy(id: string, args?: string[]): Promise<Strategy> {
+  const entry = await getStrategyEntry(id);
+  if (!entry) throw new Error(`Unknown strategy '${id}'. Use 'strategy list' to see available strategies.`);
+  return entry.create(args);
+}
+
+/** Reset and re-scan — call after a new strategy file is placed, so the next list/get picks it up. */
+export async function reload(): Promise<void> {
+  loaded = false;
+  strategyMap.clear();
+  knowledgeDocMap.clear();
+  await ensureLoaded();
+}

package/src/strategies/lone-kill-task.ts

@@ -0,0 +1,21 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { LoneKillTaskTop } from './goals/lone-kill-task-top.js';
+import { ConversationGoal } from './goals/conversation-goal.js';
+import { SpeechModule, getSpeechConfigForRole } from './speech-module.js';
+
+export const strategy: StrategyEntry = {
+  id: 'lone-kill-task',
+  description: '视野里只有一个非队友且冷却可用就靠近，进入50距离就立刻出刀；刀在冷却时不追不等、改做低优先级任务伪装，冷却好且目标仍落单可见再出刀（贴脸且刀好仍会立刻出刀）。发现尸体且附近有非队友、但当前不能原地出刀时，会靠近并报告尸体。视野里出现两人以上时，暂停攻击10秒并做任意阵营的真实任务伪装；选任务时会跳过紧挨已知尸体（含看见过、已离开视野的）的任务，不在命案现场做任务。没有可做任务时按房间巡逻，绝不停在原地。（章鱼默认）',
+  create(args?: string[]) {
+    const role = args?.[0] ?? 'neutral_octopus';
+    let convo: ConversationGoal | null = null;
+    return new GoalRootStrategy('lone-kill-task', () => {
+      convo = new ConversationGoal(() => new LoneKillTaskTop(), new SpeechModule(getSpeechConfigForRole(role)));
+      return convo;
+    }, {
+      resetOnMeetingResume: false,
+      onUpdateRole: role => convo?.updateConfig(role),
+    });
+  },
+};

package/src/strategies/meeting-gate.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import {
+  meetingEndedInEvents,
+  meetingStartedInEvents,
+  shouldPauseForMeeting,
+} from './meeting-gate.js';
+import type { GameState } from '../sdk/types.js';
+
+function baseState(overrides: Partial<GameState> = {}): GameState {
+  return {
+    phase: 'wandering',
+    tick: 1,
+    you: {
+      name: 'me',
+      x: 0,
+      y: 0,
+      room: '酒吧',
+      role: 'crab_generic',
+      faction: 'crab',
+      is_alive: true,
+    },
+    your_tasks: [],
+    players: [],
+    corpses: [],
+    stale: false,
+    ...overrides,
+  };
+}
+
+describe('meeting-gate', () => {
+  it('detects meeting end events', () => {
+    expect(meetingEndedInEvents([{ type: 'meeting_ended' }])).toBe(true);
+    expect(meetingEndedInEvents([{ type: 'meeting_result_pending' }])).toBe(true);
+    expect(meetingEndedInEvents([{ type: 'speech' }])).toBe(false);
+  });
+
+  it('keeps pausing during meeting until end events arrive', () => {
+    const during = baseState({ phase: 'meeting', new_events: [{ type: 'speech' }] });
+    expect(shouldPauseForMeeting(during)).toBe(true);
+
+    const ending = baseState({ phase: 'meeting', new_events: [{ type: 'meeting_ended' }] });
+    expect(shouldPauseForMeeting(ending)).toBe(false);
+
+    const wandering = baseState({ phase: 'wandering' });
+    expect(shouldPauseForMeeting(wandering)).toBe(false);
+  });
+
+  it('does not re-pause after releasedEarly while HTTP phase still meeting', () => {
+    const lingering = baseState({ phase: 'meeting', new_events: [] });
+    expect(shouldPauseForMeeting(lingering, true)).toBe(false);
+    expect(shouldPauseForMeeting(lingering, false)).toBe(true);
+  });
+
+  it('detects meeting start events for cycle reset', () => {
+    expect(meetingStartedInEvents([{ type: 'meeting_start' }])).toBe(true);
+    expect(meetingStartedInEvents([{ type: 'meeting_started' }])).toBe(true);
+    expect(meetingStartedInEvents([{ type: 'speech' }])).toBe(false);
+  });
+});

package/src/strategies/meeting-gate.ts

@@ -0,0 +1,23 @@
+import type { GameState } from '../sdk/types.js';
+
+const MEETING_END_EVENT_TYPES = new Set(['meeting_ended', 'meeting_result_pending']);
+const MEETING_START_EVENT_TYPES = new Set(['meeting_start', 'meeting_started']);
+
+export function meetingEndedInEvents(events: any[] | undefined): boolean {
+  return (events ?? []).some((e) => MEETING_END_EVENT_TYPES.has(e.type));
+}
+
+export function meetingStartedInEvents(events: any[] | undefined): boolean {
+  return (events ?? []).some((e) => MEETING_START_EVENT_TYPES.has(e.type));
+}
+
+/**
+ * Keep pausing while HTTP phase is still `meeting`.
+ * `releasedEarly` is set after we have seen meeting end once — avoids re-pausing
+ * on later polls where phase lags but `new_events` no longer repeats `meeting_ended`.
+ */
+export function shouldPauseForMeeting(state: GameState, releasedEarly = false): boolean {
+  if (state.phase !== 'meeting') return false;
+  if (releasedEarly) return false;
+  return !meetingEndedInEvents(state.new_events);
+}

package/src/strategies/move-room.ts

@@ -0,0 +1,15 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { MoveRoomGoal } from './goals/move-room-goal.js';
+
+export const strategy: StrategyEntry = {
+  id: 'move-room',
+  description: '前往指定房间，到达后停下。参数为目标房间名（如 酒吧）。单纯走位，不做任务、不打人、不报告。',
+  create(args?: string[]) {
+    const targetRoom = args?.join(' ').trim() ?? '';
+    if (!targetRoom) {
+      throw new Error('move-room strategy requires a room name. Example: move-room 酒吧');
+    }
+    return new GoalRootStrategy('move-room', () => new MoveRoomGoal(targetRoom));
+  },
+};

package/src/strategies/new-events-backfill.ts

@@ -0,0 +1,98 @@
+import { closeSync, existsSync, openSync, readSync, statSync } from 'fs';
+import { extractNewEvents } from '../pipeline/event-store.js';
+
+const SUPPLEMENTAL_TYPES = new Set([
+  'corpse_spotted', 'crab_teammates',
+  'meeting_ended', 'meeting_result_pending', 'meeting_start', 'meeting_started',
+  'move_end', 'move_interrupted',
+  'wandering_speech',
+]);
+
+const KEY_FIELDS = [
+  'type', 'tick', 'actor_name', 'spotted_name', 'killer_name', 'result_target',
+  'target_name', 'corpse_name', 'task_name', 'reason', 'text', 'content',
+];
+
+export function createStrategyNewEventsBackfill(eventLogPath: string): {
+  correct(stateNewEvents: any): Record<string, any>[];
+} {
+  let pos = sizeOf(eventLogPath);
+
+  return {
+    correct(stateNewEvents: any): Record<string, any>[] {
+      const httpEvents = extractNewEvents(stateNewEvents);
+      const httpKeys = new Set(httpEvents.map(eventKey));
+      const out: Array<{ event: Record<string, any>; order: number }> = [];
+      const seen = new Set<string>();
+      let order = 0;
+      const add = (evt: any, supplemental = false) => {
+        if (!evt || typeof evt !== 'object' || typeof evt.type !== 'string' || evt.synthetic) return;
+        if (supplemental && !SUPPLEMENTAL_TYPES.has(evt.type)) return;
+        const key = eventKey(evt);
+        if (supplemental && httpKeys.has(key)) return;
+        if (seen.has(key)) return;
+        seen.add(key);
+        out.push({ event: evt, order: order++ });
+      };
+
+      for (const line of readNewLines()) {
+        const events = extractNewEvents(line);
+        for (const evt of events.length > 0 ? events : [line]) add(evt, true);
+      }
+      for (const evt of httpEvents) add(evt);
+      return out.sort(compareEvents).map(item => item.event);
+    },
+  };
+
+  function readNewLines(): Record<string, any>[] {
+    if (!existsSync(eventLogPath)) { pos = 0; return []; }
+    let stat;
+    try { stat = statSync(eventLogPath); } catch { return []; }
+    if (stat.size < pos) pos = 0;
+    if (stat.size === pos) return [];
+
+    let fd: number;
+    try { fd = openSync(eventLogPath, 'r'); } catch { return []; }
+    const buf = Buffer.alloc(stat.size - pos);
+    try {
+      readSync(fd, buf, 0, buf.length, pos);
+    } finally {
+      closeSync(fd);
+    }
+
+    const cut = buf.lastIndexOf(0x0A);
+    if (cut < 0) return [];
+    const chunk = buf.subarray(0, cut).toString('utf8');
+    pos += cut + 1;
+    return chunk.split('\n').flatMap(parseLine);
+  }
+}
+
+function eventKey(evt: Record<string, any>): string {
+  return evt.tick == null ? JSON.stringify(evt) : KEY_FIELDS.map(k => evt[k] ?? '').join('|');
+}
+
+function compareEvents(a: { event: Record<string, any>; order: number }, b: { event: Record<string, any>; order: number }): number {
+  const at = typeof a.event.tick === 'number' && Number.isFinite(a.event.tick) ? a.event.tick : null;
+  const bt = typeof b.event.tick === 'number' && Number.isFinite(b.event.tick) ? b.event.tick : null;
+  if (at != null && bt != null && at !== bt) return at - bt;
+  return a.order - b.order;
+}
+
+function parseLine(line: string): Record<string, any>[] {
+  if (!line.trim()) return [];
+  try {
+    const obj = JSON.parse(line);
+    return obj && typeof obj === 'object' ? [obj] : [];
+  } catch {
+    return [];
+  }
+}
+
+function sizeOf(path: string): number {
+  try {
+    return existsSync(path) ? statSync(path).size : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/strategies/paradise-fish.knowledge.md

@@ -0,0 +1,20 @@
+# paradise-fish 知识契约
+
+`paradise-fish` 只读取统一的玩家三档标记：
+
+| 标记 | 行为 |
+|------|------|
+| `suspect` | 可疑：无尸体时进入视野便寻路远离 |
+| `hostile` | 敌对：无尸体时进入视野便寻路远离 |
+| `trusted` | 可信：可与其抱团、靠近站定伪装做任务 |
+
+天堂鱼不出刀，因此 suspect 与 hostile 都表现为回避。发现尸体时仍优先执行尸体旁游走逻辑，不报警。
+
+```bash
+ccl knowledge mark 5 suspect --confidence 0.7 --note "行为可疑"
+ccl knowledge mark 5 hostile --confidence 0.9 --note "确认危险"
+ccl knowledge mark 3 trusted --note "可以抱团"
+ccl knowledge del player 5
+```
+
+`role` 是纯身份事实，不直接控制策略。

package/src/strategies/paradise-fish.ts

@@ -0,0 +1,25 @@
+import type { StrategyEntry } from './types.js';
+import { GoalRootStrategy } from './goals/goal-root-strategy.js';
+import { ParadiseFishTop } from './goals/paradise-fish-top.js';
+import { parseGreetingArgs } from './greeting.js';
+
+class ParadiseFishStrategy extends GoalRootStrategy {
+  constructor(private readonly greetingPhrases: string[]) {
+    super('paradise-fish', () => new ParadiseFishTop(greetingPhrases), {
+      resetOnMeetingResume: false,
+    });
+  }
+
+  speechWarmupTexts(): string[] {
+    return this.greetingPhrases;
+  }
+}
+
+export const strategy: StrategyEntry = {
+  id: 'paradise-fish',
+  description:
+    '天堂鱼·进阶版（中立，不报警、不做任务，靠被投票出局取胜；corpse-patrol 的带记忆升级）。统一读取 ccl knowledge 三档标记：suspect/hostile 都视为危险并寻路远离，trusted 视为可抱团的可信同伴。发现尸体绝不报警，贴着尸体游走制造嫌疑；附近有人时远离那人但仍在尸体附近活动。传入打招呼话术时，视野内出现人就随机发送一条，之后120秒内不再发言。',
+  create(args?: string[]) {
+    return new ParadiseFishStrategy(parseGreetingArgs(args, 'paradise-fish'));
+  },
+};

package/src/strategies/pathfind/distance-field.ts

@@ -0,0 +1,150 @@
+import type { WalkableGrid } from './walkable-grid.js';
+
+// Geodesic distance field over the walkable grid, integer octile costs:
+// straight 5, diagonal 7 (~1:1.4). One tile = 4px = 5 units.
+export const COST_STRAIGHT = 5;
+export const COST_DIAG = 7;
+export const UNITS_PER_PX = COST_STRAIGHT / 4;
+export const PX_PER_UNIT = 4 / COST_STRAIGHT;
+
+export interface FieldResult {
+  /** Geodesic cost in units from the source; Infinity if unreached. Valid until the next compute(). */
+  distOf(cell: number): number;
+  /** Per angle bucket, the farthest settled cell with dist <= ringUnits; -1 for empty buckets. */
+  ringCandidates: Int32Array;
+}
+
+export class FieldCalculator {
+  private readonly dist: Int32Array;
+  private readonly stamp: Int32Array;
+  private gen = 0;
+  private source = -1;
+
+  constructor(private readonly grid: WalkableGrid) {
+    this.dist = new Int32Array(grid.width * grid.height);
+    this.stamp = new Int32Array(grid.width * grid.height);
+  }
+
+  /**
+   * Dial's-bucket Dijkstra from sourceCell, settling cells up to maxCostUnits.
+   * Diagonal steps require both orthogonal neighbors walkable (no corner
+   * cutting, matching the server's supercover line checks).
+   */
+  compute(sourceCell: number, maxCostUnits: number, ringUnits: number, bucketCount = 16): FieldResult {
+    const { grid, dist, stamp } = this;
+    const W = grid.width;
+    this.gen++;
+    this.source = sourceCell;
+    const gen = this.gen;
+
+    const ringCandidates = new Int32Array(bucketCount).fill(-1);
+    const ringDist = new Int32Array(bucketCount).fill(-1);
+    const sx = sourceCell % W;
+    const sy = Math.floor(sourceCell / W);
+
+    const buckets: (number[] | undefined)[] = new Array(maxCostUnits + COST_DIAG + 1);
+    dist[sourceCell] = 0;
+    stamp[sourceCell] = gen;
+    buckets[0] = [sourceCell];
+
+    for (let c = 0; c <= maxCostUnits; c++) {
+      const bucket = buckets[c];
+      if (!bucket) continue;
+      for (const cell of bucket) {
+        if (dist[cell] !== c || stamp[cell] !== gen) continue; // stale entry
+        const tx = cell % W;
+        const ty = Math.floor(cell / W);
+        if (c > 0 && c <= ringUnits) {
+          const b = Math.floor(((Math.atan2(ty - sy, tx - sx) + Math.PI) / (2 * Math.PI)) * bucketCount) % bucketCount;
+          if (c > ringDist[b]) {
+            ringDist[b] = c;
+            ringCandidates[b] = cell;
+          }
+        }
+        const e = grid.isWalkable(tx + 1, ty);
+        const w = grid.isWalkable(tx - 1, ty);
+        const s = grid.isWalkable(tx, ty + 1);
+        const n = grid.isWalkable(tx, ty - 1);
+        this.relax(cell + 1, c + COST_STRAIGHT, e, buckets, gen);
+        this.relax(cell - 1, c + COST_STRAIGHT, w, buckets, gen);
+        this.relax(cell + W, c + COST_STRAIGHT, s, buckets, gen);
+        this.relax(cell - W, c + COST_STRAIGHT, n, buckets, gen);
+        this.relax(cell + W + 1, c + COST_DIAG, e && s && grid.isWalkable(tx + 1, ty + 1), buckets, gen);
+        this.relax(cell + W - 1, c + COST_DIAG, w && s && grid.isWalkable(tx - 1, ty + 1), buckets, gen);
+        this.relax(cell - W + 1, c + COST_DIAG, e && n && grid.isWalkable(tx + 1, ty - 1), buckets, gen);
+        this.relax(cell - W - 1, c + COST_DIAG, w && n && grid.isWalkable(tx - 1, ty - 1), buckets, gen);
+      }
+      buckets[c] = undefined;
+    }
+
+    const distOf = (cell: number) => (stamp[cell] === gen ? dist[cell] : Infinity);
+    return { distOf, ringCandidates };
+  }
+
+  private relax(cell: number, cost: number, walkable: boolean, buckets: (number[] | undefined)[], gen: number): void {
+    if (!walkable) return;
+    if (this.stamp[cell] === gen && this.dist[cell] <= cost) return;
+    this.dist[cell] = cost;
+    this.stamp[cell] = gen;
+    (buckets[cost] ??= []).push(cell);
+  }
+
+  /**
+   * Walk from fromCell down the latest field's gradient toward its source,
+   * stopping once >= budgetUnits is spent (the last step may overshoot).
+   * Unreached cells stay frozen in place. Returns visited cells incl. ends.
+   */
+  descend(fromCell: number, budgetUnits: number): { end: number; cells: number[] } {
+    const cells = [fromCell];
+    if (this.distOfCurrent(fromCell) === Infinity) return { end: fromCell, cells };
+    let cur = fromCell;
+    let spent = 0;
+    while (spent < budgetUnits && this.distOfCurrent(cur) > 0) {
+      const next = this.bestNeighbor(cur);
+      if (next < 0) break;
+      spent += this.distOfCurrent(cur) - this.distOfCurrent(next);
+      cur = next;
+      cells.push(cur);
+    }
+    return { end: cur, cells };
+  }
+
+  /** Shrimp step path: cells from the latest field's source to fromCell. */
+  pathToSource(fromCell: number): number[] {
+    return this.descend(fromCell, Number.MAX_SAFE_INTEGER).cells.reverse();
+  }
+
+  private distOfCurrent(cell: number): number {
+    return this.stamp[cell] === this.gen ? this.dist[cell] : Infinity;
+  }
+
+  private bestNeighbor(cell: number): number {
+    const { grid } = this;
+    const W = grid.width;
+    const tx = cell % W;
+    const ty = Math.floor(cell / W);
+    const e = grid.isWalkable(tx + 1, ty);
+    const w = grid.isWalkable(tx - 1, ty);
+    const s = grid.isWalkable(tx, ty + 1);
+    const n = grid.isWalkable(tx, ty - 1);
+    let best = -1;
+    let bestDist = this.distOfCurrent(cell);
+    const consider = (c: number, walkable: boolean) => {
+      if (!walkable) return;
+      const d = this.distOfCurrent(c);
+      if (d < bestDist) {
+        bestDist = d;
+        best = c;
+      }
+    };
+    consider(cell + 1, e);
+    consider(cell - 1, w);
+    consider(cell + W, s);
+    consider(cell - W, n);
+    consider(cell + W + 1, e && s && grid.isWalkable(tx + 1, ty + 1));
+    consider(cell + W - 1, w && s && grid.isWalkable(tx - 1, ty + 1));
+    consider(cell - W + 1, e && n && grid.isWalkable(tx + 1, ty - 1));
+    consider(cell - W - 1, w && n && grid.isWalkable(tx - 1, ty - 1));
+    return best;
+  }
+}