@gemwright/ai 0.0.0 → 0.8.1

package/dist/path-worker.js

@@ -0,0 +1,1384 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/links.ts
+import { readFileSync } from "fs";
+function linkToward(here, goal, tried, start) {
+  return links.filter((link) => !tried.has(link) && distance(here, link.from) <= 150 && distance(link.to, goal) < distance(here, goal) - 20 && !(start && distance(here, start) > 30 && distance(link.to, start) <= 30)).sort((a, b) => distance(here, a.from) + distance(a.to, goal) - (distance(here, b.from) + distance(b.to, goal)))[0];
+}
+var distance = (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y)), links, teleporterTiles;
+var init_links = __esm(() => {
+  links = JSON.parse(readFileSync(new URL("../locations/teleporters.json", import.meta.url), "utf8")).links;
+  teleporterTiles = links.map((link) => `${link.from.x},${link.from.y}`);
+});
+
+// src/direct-route.ts
+function directRoute(terrain, start, goal, range, blocked, targetZ, limit = 32) {
+  const path = [];
+  let point = start;
+  for (let step = 0;step < limit; step++) {
+    const distance = Math.max(Math.abs(point.x - goal.x), Math.abs(point.y - goal.y));
+    if (distance <= range)
+      return targetZ === undefined || Math.abs(point.z - targetZ) <= 8 ? path : null;
+    const dx = Math.sign(goal.x - point.x);
+    const dy = Math.sign(goal.y - point.y);
+    const x = point.x + dx;
+    const y = point.y + dy;
+    if (blocked.has(`${x},${y}`) || teleporters.has(`${x},${y}`) && (x !== goal.x || y !== goal.y))
+      break;
+    const next = terrain.stand(x, y, point.z, point);
+    if (!next || dx && dy && (!terrain.stand(x, point.y, point.z, point) || !terrain.stand(point.x, y, point.z, point)))
+      break;
+    path.push(next);
+    point = next;
+  }
+  return path.length ? path : null;
+}
+var teleporters;
+var init_direct_route = __esm(() => {
+  init_links();
+  teleporters = new Set(teleporterTiles);
+});
+
+// src/path-search.ts
+class RouteSearch {
+  capacity;
+  budgetMs;
+  expansionBudget;
+  offRoad;
+  keys;
+  x;
+  y;
+  z;
+  costs;
+  ranks;
+  parents;
+  positions;
+  hash;
+  heap;
+  hashSize;
+  count = 0;
+  size = 0;
+  constructor(capacity = 65536, budgetMs = 500, expansionBudget, offRoad = 1.12) {
+    this.capacity = capacity;
+    this.budgetMs = budgetMs;
+    this.expansionBudget = expansionBudget;
+    this.offRoad = offRoad;
+    if (!Number.isInteger(capacity) || capacity < 1024 || capacity > 1048576 || capacity & capacity - 1)
+      throw new Error("Search capacity must be a power of two from 1024 to 1048576");
+    this.hashSize = capacity * 4;
+    this.keys = new Float64Array(capacity);
+    this.x = new Uint16Array(capacity);
+    this.y = new Uint16Array(capacity);
+    this.z = new Int16Array(capacity);
+    this.costs = new Float64Array(capacity);
+    this.ranks = new Float64Array(capacity);
+    this.parents = new Int32Array(capacity);
+    this.positions = new Int32Array(capacity);
+    this.hash = new Uint32Array(capacity * 4);
+    this.heap = new Uint32Array(capacity);
+  }
+  slot(key) {
+    let hash = (key | 0) ^ Math.floor(key / 4294967296);
+    hash = Math.imul(hash ^ hash >>> 16, 73244475);
+    hash = Math.imul(hash ^ hash >>> 16, 73244475);
+    let slot = (hash ^ hash >>> 16) >>> 0;
+    slot &= this.hashSize - 1;
+    while (this.hash[slot] && this.keys[(this.hash[slot] ?? 1) - 1] !== key)
+      slot = slot + 1 & this.hashSize - 1;
+    return slot;
+  }
+  point(index) {
+    return { x: this.x[index], y: this.y[index], z: this.z[index] };
+  }
+  push(index) {
+    let at = this.positions[index];
+    if (at < 0)
+      at = this.size++;
+    while (at > 0) {
+      const parent = at - 1 >> 1;
+      const other = this.heap[parent];
+      if (this.ranks[other] <= this.ranks[index])
+        break;
+      this.heap[at] = other;
+      this.positions[other] = at;
+      at = parent;
+    }
+    this.heap[at] = index;
+    this.positions[index] = at;
+  }
+  pop() {
+    const first = this.heap[0];
+    const last = this.heap[--this.size];
+    if (this.size) {
+      let at = 0;
+      while (at * 2 + 1 < this.size) {
+        let child = at * 2 + 1;
+        if (child + 1 < this.size && this.ranks[this.heap[child + 1]] < this.ranks[this.heap[child]])
+          child++;
+        const other = this.heap[child];
+        if (this.ranks[other] >= this.ranks[last])
+          break;
+        this.heap[at] = other;
+        this.positions[other] = at;
+        at = child;
+      }
+      this.heap[at] = last;
+      this.positions[last] = at;
+    }
+    this.positions[first] = -1;
+    return first;
+  }
+  run(terrain, request, cancelled = () => false) {
+    const began = performance.now();
+    this.hash.fill(0);
+    this.positions.fill(-1);
+    this.count = 1;
+    this.size = 0;
+    const { start, goal, range, targetZ } = request;
+    const MAX_STEP_Z = 8;
+    const blocked = new Set(request.blocked);
+    const penalties = new Set(request.penalties ?? []);
+    const estimate = (x, y) => {
+      const dx = Math.abs(x - goal.x), dy = Math.abs(y - goal.y);
+      return (Math.max(dx, dy) + 0.4 * Math.min(dx, dy)) * 1.1;
+    };
+    const distance = (x, y) => Math.max(Math.abs(x - goal.x), Math.abs(y - goal.y));
+    const add = (index, point, key, slot) => {
+      this.keys[index] = key;
+      this.x[index] = point.x;
+      this.y[index] = point.y;
+      this.z[index] = point.z;
+      this.hash[slot] = index + 1;
+    };
+    const key = coordinate(start.x, start.y, start.z);
+    add(0, start, key, this.slot(key));
+    this.parents[0] = -1;
+    this.costs[0] = 0;
+    this.ranks[0] = estimate(start.x, start.y);
+    this.push(0);
+    let expanded = 0;
+    let best = 0;
+    let found = -1;
+    let exhausted = false;
+    const expansionLimit = this.expansionBudget ?? (distance(start.x, start.y) <= 38 && !request.wide ? 8192 : 200000);
+    const current = { ...start };
+    const height = (x, y) => terrain.standingZ ? terrain.standingZ(x, y, current.z, current) : terrain.stand(x, y, current.z, current)?.z;
+    outer:
+      while (this.size && expanded < expansionLimit) {
+        if ((expanded & 63) === 0 && (cancelled() || performance.now() - began > this.budgetMs)) {
+          exhausted = true;
+          break;
+        }
+        const index = this.pop();
+        current.x = this.x[index];
+        current.y = this.y[index];
+        current.z = this.z[index];
+        expanded++;
+        const d = distance(current.x, current.y);
+        if (d < distance(this.x[best], this.y[best]))
+          best = index;
+        if (d <= range && (targetZ === undefined || Math.abs(current.z - targetZ) <= 8)) {
+          found = index;
+          break;
+        }
+        for (const [dx, dy] of directions) {
+          const x = current.x + dx;
+          const y = current.y + dy;
+          if (x < 1 || y < 1 || x > 7165 || y > 4093 || blocked.has(`${x},${y}`))
+            continue;
+          const nextZ = height(x, y);
+          if (nextZ === undefined || Math.abs(nextZ - current.z) > MAX_STEP_Z || dx && dy && (height(x, current.y) === undefined || height(current.x, y) === undefined))
+            continue;
+          const key = coordinate(x, y, nextZ);
+          const slot = this.slot(key);
+          let other = this.hash[slot] - 1;
+          const road = isRoad(terrain, terrain.cell(x, y).land.id);
+          const parent = this.parents[index];
+          const turn = parent >= 0 && (Math.sign(current.x - this.x[parent]) !== dx || Math.sign(current.y - this.y[parent]) !== dy);
+          const trouble = penalties.size && penalties.has((x >> 3) * 1024 + (y >> 3)) ? request.penaltyCost ?? 4 : 0;
+          const vary = request.seed ? (((x >> 2) * 73856093 ^ (y >> 2) * 19349663 ^ request.seed) & 1023) / 3000 : 0;
+          const cost = this.costs[index] + (dx && dy ? 1.4 : 1) * (road ? 1 : this.offRoad) + (turn ? 0.08 : 0) + trouble + vary;
+          if (other >= 0 && this.costs[other] <= cost)
+            continue;
+          if (other < 0) {
+            if (this.count === this.capacity) {
+              exhausted = true;
+              break outer;
+            }
+            other = this.count++;
+            add(other, { x, y, z: nextZ }, key, slot);
+          }
+          this.costs[other] = cost;
+          this.ranks[other] = cost + estimate(x, y);
+          this.parents[other] = index;
+          this.push(other);
+        }
+      }
+    if (expanded >= expansionLimit)
+      exhausted = true;
+    if (cancelled())
+      return { path: null, expanded, exhausted, elapsedMs: performance.now() - began };
+    if (found < 0 && request.partial && distance(this.x[best], this.y[best]) < distance(start.x, start.y) - 8)
+      found = best;
+    let path = null;
+    if (found >= 0) {
+      path = [];
+      for (let index = found, steps = 0;this.parents[index] >= 0 && steps < this.capacity; steps++, index = this.parents[index])
+        path.push(this.point(index));
+      path.reverse();
+    }
+    return { path, expanded, exhausted, elapsedMs: performance.now() - began };
+  }
+}
+var directions, coordinate = (x, y, z) => (x * 4096 + y) * 512 + z + 256, roads, isRoad = (terrain, id) => {
+  let road = roads.get(id);
+  if (road === undefined) {
+    road = /cobble|flagstone|pavement|paver|road|dirt/i.test(terrain.tile(id).name);
+    roads.set(id, road);
+  }
+  return road;
+}, routeSeed = (goal, now = Date.now()) => goal.x * 73856093 ^ goal.y * 19349663 ^ Math.imul(Math.floor(now / 600000), 83492791) | 1;
+var init_path_search = __esm(() => {
+  directions = [
+    [0, -1],
+    [1, -1],
+    [1, 0],
+    [1, 1],
+    [0, 1],
+    [-1, 1],
+    [-1, 0],
+    [-1, -1]
+  ];
+  roads = new Map;
+});
+
+// ../common/src/assets/tiledata.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join } from "path";
+
+class Tiledata {
+  bytes;
+  constructor(directory) {
+    this.bytes = readFileSync3(join(directory, "tiledata.mul"));
+  }
+  item(id) {
+    const at = ITEMS + (id >> 5) * (4 + 32 * 41) + 4 + (id & 31) * 41;
+    if (at + 41 > this.bytes.length)
+      return { name: "", weight: 0, layer: 0, animation: 0, height: 0, partialHue: false };
+    return {
+      name: this.bytes.subarray(at + 21, at + 41).toString("latin1").split("\x00")[0] ?? "",
+      weight: this.bytes.readUInt8(at + 8),
+      layer: this.bytes.readUInt8(at + 9),
+      animation: this.bytes.readUInt16LE(at + 14),
+      height: this.bytes.readUInt8(at + 20),
+      partialHue: !!(this.bytes.readUInt32LE(at) & PARTIAL_HUE)
+    };
+  }
+}
+var ITEMS, PARTIAL_HUE = 262144, TileFlag;
+var init_tiledata = __esm(() => {
+  ITEMS = 512 * (4 + 32 * 30);
+  TileFlag = {
+    Background: 1,
+    Weapon: 2,
+    Transparent: 4,
+    Translucent: 8,
+    Wall: 16,
+    Damaging: 32,
+    Impassable: 64,
+    Wet: 128,
+    Surface: 512,
+    Bridge: 1024,
+    Generic: 2048,
+    Window: 4096,
+    NoShoot: 8192,
+    Foliage: 131072,
+    PartialHue: 262144,
+    Map: 1048576,
+    Container: 2097152,
+    Wearable: 4194304,
+    LightSource: 8388608,
+    Animation: 16777216,
+    Armor: 134217728,
+    Door: 536870912,
+    StairBack: 1073741824
+  };
+});
+// ../common/src/assets/uop.ts
+function nameHash(name) {
+  const data = Buffer.from(name);
+  let a = data.length + 3735928559 >>> 0;
+  let b = a;
+  let c = a;
+  const rot = (v, n) => v << n | v >>> 32 - n;
+  let offset = 0;
+  while (data.length - offset > 12) {
+    a = a + data.readUInt32LE(offset) >>> 0;
+    b = b + data.readUInt32LE(offset + 4) >>> 0;
+    c = c + data.readUInt32LE(offset + 8) >>> 0;
+    a = (a - c ^ rot(c, 4)) >>> 0;
+    c = c + b >>> 0;
+    b = (b - a ^ rot(a, 6)) >>> 0;
+    a = a + c >>> 0;
+    c = (c - b ^ rot(b, 8)) >>> 0;
+    b = b + a >>> 0;
+    a = (a - c ^ rot(c, 16)) >>> 0;
+    c = c + b >>> 0;
+    b = (b - a ^ rot(a, 19)) >>> 0;
+    a = a + c >>> 0;
+    c = (c - b ^ rot(b, 4)) >>> 0;
+    b = b + a >>> 0;
+    offset += 12;
+  }
+  for (let i = 0;offset + i < data.length; i++) {
+    const value = (data[offset + i] ?? 0) << i % 4 * 8;
+    if (i < 4)
+      a = a + value >>> 0;
+    else if (i < 8)
+      b = b + value >>> 0;
+    else
+      c = c + value >>> 0;
+  }
+  c = (c ^ b) - rot(b, 14) >>> 0;
+  a = (a ^ c) - rot(c, 11) >>> 0;
+  b = (b ^ a) - rot(a, 25) >>> 0;
+  c = (c ^ b) - rot(b, 16) >>> 0;
+  a = (a ^ c) - rot(c, 4) >>> 0;
+  b = (b ^ a) - rot(a, 14) >>> 0;
+  c = (c ^ b) - rot(b, 24) >>> 0;
+  return BigInt(b) << 32n | BigInt(c);
+}
+var init_uop = () => {};
+
+// ../network/src/diagnostics.ts
+function onNetworkTiming(observer) {
+  observers.add(observer);
+  return () => {
+    observers.delete(observer);
+  };
+}
+function timed(label, run) {
+  if (!observers.size)
+    return run();
+  const start = performance.now();
+  try {
+    return run();
+  } finally {
+    const sample = { label, ms: performance.now() - start };
+    for (const observer of observers) {
+      try {
+        observer(sample);
+      } catch {}
+    }
+  }
+}
+var observers;
+var init_diagnostics = __esm(() => {
+  observers = new Set;
+});
+
+// src/stall-probe.ts
+function timed2(label, run) {
+  const start = performance.now();
+  try {
+    return run();
+  } finally {
+    const ms = performance.now() - start;
+    recordSlice({ label, ms });
+  }
+}
+function recordSlice({ label, ms }) {
+  const slice = slices.get(label);
+  if (slice) {
+    slice.ms += ms;
+    slice.count++;
+    if (ms > slice.max)
+      slice.max = ms;
+  } else
+    slices.set(label, { ms, count: 1, max: ms });
+}
+function drainSlices() {
+  const out = Object.fromEntries([...slices].map(([label, s]) => [label, { ms: +s.ms.toFixed(2), count: s.count, max: +s.max.toFixed(2) }]));
+  slices.clear();
+  return out;
+}
+var slices;
+var init_stall_probe = __esm(() => {
+  init_diagnostics();
+  slices = new Map;
+  onNetworkTiming(recordSlice);
+});
+
+// src/path-pool.ts
+import { Worker } from "worker_threads";
+var PathPool;
+var init_path_pool = __esm(() => {
+  init_stall_probe();
+  PathPool = class PathPool {
+    static pools = new Map;
+    static get(directory, facet, buffers) {
+      const key = `${directory}:${facet}`;
+      let pool = PathPool.pools.get(key);
+      if (!pool) {
+        pool = new PathPool(directory, facet, 2, buffers);
+        PathPool.pools.set(key, pool);
+      }
+      return pool;
+    }
+    static closeAll() {
+      for (const pool of PathPool.pools.values())
+        pool.close();
+      PathPool.pools.clear();
+    }
+    static statistics() {
+      return [...PathPool.pools.values()].map((p) => ({
+        ...p.stats,
+        queued: p.queue.length,
+        active: p.slots.filter((s) => s.job).length
+      }));
+    }
+    queue = [];
+    slots = [];
+    next = 0;
+    closed = false;
+    stats = {
+      submitted: 0,
+      completed: 0,
+      cancelled: 0,
+      exhausted: 0,
+      maxQueue: 0,
+      maxComputeMs: 0,
+      maxWaitMs: 0
+    };
+    constructor(directory, facet, size = 2, buffers) {
+      for (let index = 0;index < size; index++) {
+        const worker = new Worker(new URL(`./path-worker${import.meta.url.endsWith(".ts") ? ".ts" : ".js"}`, import.meta.url), {
+          workerData: { directory, facet, buffers }
+        });
+        const slot = { worker };
+        this.slots.push(slot);
+        worker.on("message", (message) => timed2("path-result", () => {
+          const job = slot.job;
+          if (!job || message.id !== job.id)
+            return;
+          slot.job = undefined;
+          job.cleanup();
+          this.stats.completed++;
+          if (message.result) {
+            this.stats.exhausted += Number(message.result.exhausted);
+            this.stats.maxComputeMs = Math.max(this.stats.maxComputeMs, message.result.elapsedMs);
+            job.resolve(message.result);
+          } else
+            job.reject(new Error(message.error ?? "Path worker failed"));
+          this.dispatch();
+        }));
+        worker.on("error", (error) => this.fail(error instanceof Error ? error : new Error(String(error))));
+        worker.on("exit", (code) => {
+          if (!this.closed)
+            this.fail(new Error(`Path worker exited (${code})`));
+        });
+        worker.unref();
+      }
+    }
+    run(request, signal) {
+      if (this.closed)
+        return Promise.reject(new Error("Pathfinding pool is closed"));
+      if (signal?.aborted)
+        return Promise.reject(new Error("Pathfinding cancelled"));
+      if (this.queue.length >= 512)
+        return Promise.reject(new Error("Pathfinding queue is full"));
+      return new Promise((resolve, reject) => {
+        const cancellation = new Int32Array(new SharedArrayBuffer(4));
+        const abort = () => {
+          Atomics.store(cancellation, 0, 1);
+          this.stats.cancelled++;
+          const index = this.queue.indexOf(job);
+          if (index >= 0)
+            this.queue.splice(index, 1);
+          job.cleanup();
+          reject(new Error("Pathfinding cancelled"));
+        };
+        const job = {
+          id: ++this.next,
+          request,
+          cancellation,
+          resolve,
+          reject,
+          started: performance.now(),
+          cleanup: () => signal?.removeEventListener("abort", abort)
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+        this.queue.push(job);
+        this.stats.submitted++;
+        this.stats.maxQueue = Math.max(this.stats.maxQueue, this.queue.length);
+        this.dispatch();
+      });
+    }
+    dispatch() {
+      for (const slot of this.slots) {
+        if (slot.job)
+          continue;
+        const job = this.queue.shift();
+        if (!job) {
+          slot.worker.unref();
+          continue;
+        }
+        slot.job = job;
+        slot.worker.ref();
+        this.stats.maxWaitMs = Math.max(this.stats.maxWaitMs, performance.now() - job.started);
+        slot.worker.postMessage({ id: job.id, request: job.request, cancellation: job.cancellation.buffer });
+      }
+    }
+    fail(error) {
+      for (const job of [...this.queue, ...this.slots.flatMap((s) => s.job ? [s.job] : [])]) {
+        job.cleanup();
+        job.reject(error);
+      }
+      this.close();
+    }
+    close() {
+      this.closed = true;
+      for (const job of [...this.queue, ...this.slots.flatMap((s) => s.job ? [s.job] : [])]) {
+        Atomics.store(job.cancellation, 0, 1);
+        job.cleanup();
+        job.reject(new Error("Pathfinding pool closed"));
+      }
+      this.queue.length = 0;
+      for (const slot of this.slots) {
+        slot.job = undefined;
+        slot.worker.terminate();
+      }
+    }
+  };
+});
+
+// src/lasting.ts
+function lasting(name, scope) {
+  const entries = table(name);
+  const prefix = scope === undefined ? "" : `${scope}|`;
+  return {
+    get: (key) => entries.get(prefix + key),
+    active: (key) => (entries.get(prefix + key) ?? 0) > Date.now(),
+    set: (key, until) => {
+      if (entries.size > LIMIT)
+        prune(entries);
+      entries.set(prefix + key, until);
+    },
+    entries: () => entries.entries(),
+    count: () => {
+      let n = 0;
+      for (const [key, until] of entries)
+        if (key.startsWith(prefix) && until > Date.now())
+          n++;
+      return n;
+    }
+  };
+}
+function prune(entries) {
+  const now = Date.now();
+  for (const [key, until] of entries)
+    if (until <= now)
+      entries.delete(key);
+}
+function loadLasting(json) {
+  if (!json)
+    return;
+  try {
+    const now = Date.now();
+    for (const [name, rows] of Object.entries(JSON.parse(json)))
+      for (const [key, until] of rows)
+        if (until > now)
+          table(name).set(key, until);
+  } catch {}
+}
+function saveLasting() {
+  const out = {};
+  for (const [name, entries] of tables) {
+    prune(entries);
+    out[name] = [...entries];
+  }
+  return JSON.stringify(out);
+}
+var tables, LIMIT = 20000, table = (name) => {
+  const found = tables.get(name) ?? new Map;
+  tables.set(name, found);
+  return found;
+};
+var init_lasting = __esm(() => {
+  tables = new Map;
+});
+
+// src/telemetry-metrics.ts
+class RuntimeMetrics {
+  counters = new Map;
+  histograms = new Map;
+  starts = new Map;
+  increment(name, amount = 1) {
+    const key = this.counters.has(name) || this.counters.size < 512 ? name : "other";
+    this.counters.set(key, (this.counters.get(key) ?? 0) + amount);
+  }
+  duration(name, ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+      return;
+    const key = this.histograms.has(name) || this.histograms.size < 64 ? name : "other";
+    const histogram = this.histograms.get(key) ?? { count: 0, sum: 0, max: 0, buckets: bounds.map(() => 0) };
+    histogram.count++;
+    histogram.sum += ms;
+    histogram.max = Math.max(histogram.max, ms);
+    const index = bounds.findIndex((bound) => ms <= bound);
+    histogram.buckets[index] = (histogram.buckets[index] ?? 0) + 1;
+    this.histograms.set(key, histogram);
+  }
+  observe(event) {
+    this.increment(`${event.component}.${event.type}.${event.result}`);
+    if (event.type !== "action_lifecycle" || !event.actionId)
+      return;
+    if (["proposed", "authorized", "dispatched", "started"].includes(event.result)) {
+      if (!this.starts.has(event.actionId))
+        this.starts.set(event.actionId, Date.parse(event.at));
+      if (this.starts.size > 4096)
+        this.starts.delete(this.starts.keys().next().value ?? "");
+    } else if (["completed", "failed", "interrupted", "timed-out", "unconfirmed"].includes(event.result)) {
+      const start = this.starts.get(event.actionId);
+      if (start !== undefined)
+        this.duration("action_ms", Date.parse(event.at) - start);
+      this.starts.delete(event.actionId);
+    }
+  }
+  snapshot() {
+    return {
+      counters: Object.fromEntries(this.counters),
+      histograms: Object.fromEntries([...this.histograms].map(([name, h]) => {
+        const percentile = (fraction) => {
+          let count = 0;
+          for (let i = 0;i < bounds.length; i++) {
+            count += h.buckets[i] ?? 0;
+            if (count >= h.count * fraction)
+              return bounds[i] === Infinity ? h.max : bounds[i];
+          }
+          return h.max;
+        };
+        return [
+          name,
+          {
+            count: h.count,
+            mean: h.sum / Math.max(1, h.count),
+            max: h.max,
+            p50: percentile(0.5),
+            p95: percentile(0.95),
+            p99: percentile(0.99)
+          }
+        ];
+      }))
+    };
+  }
+}
+function markThreat(session, active, at) {
+  if (!active) {
+    threats.delete(session);
+    return;
+  }
+  if (!threats.has(session))
+    threats.set(session, { at, recorded: new Set });
+}
+function observeInterruption(session, event) {
+  const threat = threats.get(session);
+  const name = event.stage === "interrupted" ? "work_interrupt_ms" : event.kind === "escape" && event.stage === "authorized" && !event.command ? "safety_authorize_ms" : undefined;
+  if (!threat || !name || threat.recorded.has(name))
+    return;
+  runtimeMetrics.duration(name, event.at - threat.at);
+  threat.recorded.add(name);
+}
+var bounds, runtimeMetrics, threats;
+var init_telemetry_metrics = __esm(() => {
+  bounds = [1, 5, 10, 25, 50, 100, 250, 500, 1000, 5000, 30000, Infinity];
+  runtimeMetrics = new RuntimeMetrics;
+  threats = new WeakMap;
+});
+
+// src/telemetry-schema.ts
+function redact(value, depth = 0, seen = new WeakSet) {
+  if (depth > 12)
+    return "[depth-limit]";
+  if (value instanceof Error)
+    return { name: value.name, message: String(redact(value.message, depth + 1, seen)) };
+  if (typeof value === "string")
+    return value.replace(/\b(Bearer\s+)\S+/gi, "$1[redacted]").replace(/\b(password|api[_-]?key|secret|token)=([^\s&]+)/gi, "$1=[redacted]");
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    return "[circular]";
+  seen.add(value);
+  try {
+    if (Array.isArray(value))
+      return value.map((item) => redact(item, depth + 1, seen));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+      key,
+      sensitive.test(key) ? "[redacted]" : redact(item, depth + 1, seen)
+    ]));
+  } finally {
+    seen.delete(value);
+  }
+}
+var sensitive;
+var init_telemetry_schema = __esm(() => {
+  sensitive = /^(?:password|passwd|secret|authorization|cookie|token|api[_-]?key|credentials|accountRef|username)$/i;
+});
+
+// src/telemetry.ts
+import { AsyncLocalStorage } from "async_hooks";
+function updateTrace(fields) {
+  const current = context.getStore();
+  if (current)
+    Object.assign(current, fields);
+}
+function registerActor(session, residentId, name) {
+  const actor = { residentId, name, sessionId: crypto.randomUUID() };
+  actors.set(session, actor);
+  return actor;
+}
+function actorFor(session) {
+  return {
+    ...actors.get(session) ?? { residentId: null, name: null, sessionId: null },
+    position: session.world.position ? { map: session.world.map, ...session.world.position } : null
+  };
+}
+function configureTelemetry(options) {
+  const previous = { sink, output };
+  sink = options.sink ?? sink;
+  output = options.output ?? output;
+  return () => {
+    sink = previous.sink;
+    output = previous.output;
+  };
+}
+function makeEvent(component, type, result, details, fields = {}) {
+  const current = context.getStore();
+  const actor = current?.actor?.();
+  return {
+    schemaVersion: 2,
+    id: crypto.randomUUID(),
+    at: new Date().toISOString(),
+    runId,
+    deploymentId: process.env.RAILWAY_DEPLOYMENT_ID ?? null,
+    sequence: ++sequence,
+    component,
+    message: String(redact(typeof details.message === "string" ? details.message : `${component}: ${type} ${result}`)),
+    level: result === "failed" ? "error" : "info",
+    type,
+    result,
+    residentId: actor?.residentId ?? null,
+    name: actor?.name ?? null,
+    sessionId: actor?.sessionId ?? null,
+    traceId: current?.traceId ?? current?.intentId ?? current?.actionId ?? actor?.sessionId ?? runId,
+    intentId: current?.intentId,
+    decisionId: current?.decisionId,
+    actionId: current?.actionId,
+    parentId: current?.parentId,
+    position: actor?.position ?? null,
+    ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)),
+    details: redact(details)
+  };
+}
+function emitEvent(event, options = {}) {
+  runtimeMetrics.observe(event);
+  if (options.journal !== false)
+    sink?.(event);
+  if (options.stdout)
+    output?.(JSON.stringify(event), event.level);
+}
+function operational(component, level, message, details = {}) {
+  const event = makeEvent(component, "operational_log", level === "error" ? "failed" : "observed", { message, ...details }, { level });
+  emitEvent(event, { stdout: true });
+  return event;
+}
+function checkpointEvent(checkpoint, component, type, result, details, fields = {}) {
+  const session = checkpointSession(checkpoint);
+  emitEvent(makeEvent(component, type, result, details, { ...session ? actorFor(session) : {}, ...fields }));
+}
+var context, runId, sequence = 0, sink, output, actors, checkpoints, traceContext = () => context.getStore(), inTrace = (fields, run) => context.run({ ...context.getStore(), ...fields }, run), inSession = (session, run) => inTrace({ actor: () => actorFor(session) }, run), bindCheckpoint = (checkpoint, session) => checkpoints.set(checkpoint, session), checkpointSession = (checkpoint) => checkpoints.get(checkpoint);
+var init_telemetry = __esm(() => {
+  init_telemetry_metrics();
+  init_telemetry_schema();
+  context = new AsyncLocalStorage;
+  runId = crypto.randomUUID();
+  actors = new WeakMap;
+  checkpoints = new WeakMap;
+});
+
+// src/log.ts
+function logToStdout() {
+  if (structured)
+    return;
+  structured = true;
+  configureTelemetry({ output: (line, level) => level === "error" ? original.error(line) : original.log(line) });
+  for (const [method, level] of [
+    ["log", "info"],
+    ["warn", "warn"],
+    ["error", "error"]
+  ])
+    console[method] = (...values) => {
+      operational("runtime", level, values.length === 1 ? values[0] : values);
+    };
+}
+var structured = false, original, info = (line, component = "resident", details = {}) => structured ? operational(component, "info", line, details) : original.error(line), error = (component, message) => structured ? operational(component, "error", message) : original.error(message), logger = (component) => ({
+  info: (message, details = {}) => info(message, component, details),
+  error: (message) => error(component, message)
+});
+var init_log = __esm(() => {
+  init_telemetry();
+  original = {
+    log: console.log.bind(console),
+    error: console.error.bind(console),
+    warn: console.warn.bind(console)
+  };
+});
+
+// src/tuning.ts
+import { readFileSync as readFileSync4 } from "fs";
+var WALKING_LIMIT = 300, tuning;
+var init_tuning = __esm(() => {
+  tuning = JSON.parse(readFileSync4(new URL("../tuning.json", import.meta.url), "utf8"));
+});
+
+// src/trouble.ts
+function noteTrouble(at, kind) {
+  events.set(`${at.x >> CELL},${at.y >> CELL}|${kind}|${Date.now()}`, Date.now() + HOLD_MS);
+  cached.at = 0;
+}
+function tally() {
+  const cells = new Map;
+  for (const [key, until] of events.entries()) {
+    if (until <= Date.now())
+      continue;
+    const [cell = "", kind = ""] = key.split("|");
+    const entry = cells.get(cell) ?? { total: 0, kinds: new Map };
+    cells.set(cell, entry);
+    entry.total++;
+    entry.kinds.set(kind, (entry.kinds.get(kind) ?? 0) + 1);
+  }
+  return cells;
+}
+function troubleCells() {
+  if (Date.now() - cached.at < 60000)
+    return cached.cells;
+  const cells = [...tally()].filter(([, entry]) => entry.total >= PENALTY_AT).map(([cell]) => {
+    const [cx = 0, cy = 0] = cell.split(",").map(Number);
+    return cx * 1024 + cy;
+  });
+  cached = { at: Date.now(), cells };
+  return cells;
+}
+function reportTrouble() {
+  const worst = [...tally()].sort(([, a], [, b]) => b.total - a.total).slice(0, 8);
+  if (!worst.length)
+    return;
+  const place = (cell) => {
+    const [cx = 0, cy = 0] = cell.split(",").map(Number);
+    return `${(cx << CELL) + 4},${(cy << CELL) + 4}`;
+  };
+  logger("trouble").info(`[trouble] ${worst.map(([cell, e]) => `${place(cell)} \xD7${e.total} (${[...e.kinds].map(([k, n]) => `${k} ${n}`).join(", ")})`).join("; ")}`);
+}
+var CELL = 3, HOLD_MS, PENALTY_AT, events, cached;
+var init_trouble = __esm(() => {
+  init_lasting();
+  init_log();
+  init_tuning();
+  HOLD_MS = tuning.trouble.holdHours * 3600000;
+  PENALTY_AT = tuning.trouble.penaltyAt;
+  events = lasting("trouble");
+  cached = { at: 0, cells: [] };
+});
+
+// src/terrain.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join2 } from "path";
+import { inflateSync } from "zlib";
+function directionTo(from, to) {
+  return directions2.findIndex(([x, y]) => x === Math.sign(to.x - from.x) && y === Math.sign(to.y - from.y));
+}
+var directions2, Terrain;
+var init_terrain = __esm(() => {
+  init_tiledata();
+  init_uop();
+  init_links();
+  init_path_pool();
+  init_path_search();
+  init_trouble();
+  init_tuning();
+  directions2 = [
+    [0, -1],
+    [1, -1],
+    [1, 0],
+    [1, 1],
+    [0, 1],
+    [-1, 1],
+    [-1, 0],
+    [-1, -1]
+  ];
+  Terrain = class Terrain {
+    directory;
+    facet;
+    tileCache = new Map;
+    localSearch;
+    shared;
+    cacheKeys = new Uint32Array(32768);
+    cacheCursor = 0;
+    map;
+    index;
+    statics;
+    tiles;
+    cache = new Map;
+    static instances = new Map;
+    static shared(directory, facet = 1, buffers) {
+      const key = `${directory}:${facet}`;
+      let terrain = Terrain.instances.get(key);
+      if (!terrain) {
+        terrain = new Terrain(directory, facet, buffers);
+        Terrain.instances.set(key, terrain);
+      }
+      return terrain;
+    }
+    constructor(directory, facet = 1, buffers) {
+      this.directory = directory;
+      this.facet = facet;
+      if (buffers) {
+        this.map = Buffer.from(buffers.map);
+        this.index = Buffer.from(buffers.index);
+        this.statics = Buffer.from(buffers.statics);
+        this.tiles = Buffer.from(buffers.tiles);
+        this.shared = buffers;
+        return;
+      }
+      this.tiles = readFileSync5(join2(directory, "tiledata.mul"));
+      if (this.tiles.length !== 3188736)
+        throw new Error("Terrain requires the modern 64-bit tiledata format");
+      this.index = readFileSync5(join2(directory, `staidx${facet}.mul`));
+      this.statics = readFileSync5(join2(directory, `statics${facet}.mul`));
+      const uop = readFileSync5(join2(directory, `map${facet}LegacyMUL.uop`));
+      if (uop.readUInt32LE(0) !== 5265741)
+        throw new Error("Invalid map UOP");
+      const entries = new Map;
+      const visited = new Set;
+      for (let block = Number(uop.readBigUInt64LE(12));block !== 0; ) {
+        if (visited.has(block))
+          throw new Error("Cyclic map UOP");
+        visited.add(block);
+        const count = uop.readUInt32LE(block);
+        const next = Number(uop.readBigUInt64LE(block + 4));
+        for (let i = 0;i < count; i++) {
+          const at = block + 12 + i * 34;
+          const offset = Number(uop.readBigUInt64LE(at));
+          if (!offset)
+            continue;
+          const start = offset + uop.readUInt32LE(at + 8);
+          const length = uop.readUInt32LE(at + 12);
+          const bytes = uop.subarray(start, start + length);
+          const value = uop.readUInt16LE(at + 32) === 1 ? inflateSync(bytes) : bytes;
+          if (value.length !== uop.readUInt32LE(at + 16))
+            throw new Error("Truncated map chunk");
+          entries.set(uop.readBigUInt64LE(at + 20), value);
+        }
+        block = next;
+      }
+      const chunks = [];
+      const expected = 7168 * 4096 / 64 * 196;
+      for (let i = 0;chunks.reduce((sum, chunk) => sum + chunk.length, 0) < expected; i++) {
+        const chunk = entries.get(nameHash(`build/map${facet}legacymul/${String(i).padStart(8, "0")}.dat`));
+        if (!chunk)
+          throw new Error(`Missing map chunk ${i}`);
+        chunks.push(chunk);
+      }
+      this.map = Buffer.concat(chunks);
+      if (this.map.length !== expected)
+        throw new Error("Unexpected map dimensions");
+    }
+    sharedBuffers() {
+      if (!this.shared) {
+        const copy = (bytes) => {
+          const memory = new SharedArrayBuffer(bytes.length);
+          new Uint8Array(memory).set(bytes);
+          return memory;
+        };
+        this.shared = {
+          map: copy(this.map),
+          index: copy(this.index),
+          statics: copy(this.statics),
+          tiles: copy(this.tiles)
+        };
+        this.map = Buffer.from(this.shared.map);
+        this.index = Buffer.from(this.shared.index);
+        this.statics = Buffer.from(this.shared.statics);
+        this.tiles = Buffer.from(this.shared.tiles);
+      }
+      return this.shared;
+    }
+    tile(id, item = false) {
+      const key = id + (item ? 65536 : 0);
+      const cached = this.tileCache.get(key);
+      if (cached)
+        return cached;
+      const base = item ? 493568 : 0;
+      const size = item ? 41 : 30;
+      const offset = base + (id >> 5) * (4 + 32 * size) + 4 + (id & 31) * size;
+      const value = {
+        flags: this.tiles.readUInt32LE(offset),
+        height: item ? this.tiles.readUInt8(offset + 20) : 0,
+        layer: item ? this.tiles.readUInt8(offset + 9) : 0,
+        name: this.tiles.subarray(offset + (item ? 21 : 10), offset + size).toString("latin1").split("\x00")[0] ?? ""
+      };
+      this.tileCache.set(key, value);
+      return value;
+    }
+    findStatics(ids, origin, radius) {
+      const matches = [];
+      const minX = Math.max(0, origin.x - radius >> 3);
+      const maxX = Math.min(895, origin.x + radius >> 3);
+      const minY = Math.max(0, origin.y - radius >> 3);
+      const maxY = Math.min(511, origin.y + radius >> 3);
+      for (let bx = minX;bx <= maxX; bx++)
+        for (let by = minY;by <= maxY; by++) {
+          const block = bx * 512 + by;
+          const start = this.index.readInt32LE(block * 12);
+          const length = this.index.readInt32LE(block * 12 + 4);
+          if (start < 0 || length <= 0)
+            continue;
+          for (let offset = start;offset < start + length; offset += 7) {
+            const id = this.statics.readUInt16LE(offset);
+            if (!ids.has(id))
+              continue;
+            const x = bx * 8 + this.statics.readUInt8(offset + 2);
+            const y = by * 8 + this.statics.readUInt8(offset + 3);
+            if (Math.max(Math.abs(x - origin.x), Math.abs(y - origin.y)) <= radius)
+              matches.push({ id, x, y, z: this.statics.readInt8(offset + 4) });
+          }
+        }
+      return matches.sort((a, b) => Math.max(Math.abs(a.x - origin.x), Math.abs(a.y - origin.y)) - Math.max(Math.abs(b.x - origin.x), Math.abs(b.y - origin.y)));
+    }
+    sight(from, to) {
+      const steps = Math.max(Math.abs(to.x - from.x), Math.abs(to.y - from.y));
+      if (steps === 0)
+        return true;
+      const fromZ = from.z ?? 0;
+      const toZ = to.z ?? fromZ;
+      for (let step = 1;step < steps; step++) {
+        const x = Math.round(from.x + (to.x - from.x) * step / steps);
+        const y = Math.round(from.y + (to.y - from.y) * step / steps);
+        const z = fromZ + (toZ - fromZ) * step / steps;
+        const { land, statics } = this.cell(x, y);
+        if (this.tile(land.id).flags & (TileFlag.Wall | TileFlag.Impassable))
+          return false;
+        for (const staticTile of statics) {
+          if (staticTile.z > z + 16 || staticTile.z + 20 < z - 4)
+            continue;
+          if (this.tile(staticTile.id, true).flags & (TileFlag.Wall | TileFlag.Impassable | TileFlag.Window | TileFlag.NoShoot))
+            return false;
+        }
+      }
+      return true;
+    }
+    cell(x, y) {
+      if (x < 0 || x >= 7167 || y < 0 || y >= 4095)
+        throw new Error("Terrain coordinate outside supported facet");
+      const key = x * 4096 + y;
+      const cached = this.cache.get(key);
+      if (cached)
+        return cached;
+      const block = (x >> 3) * 512 + (y >> 3);
+      const at = block * 196 + 4 + ((y & 7) * 8 + (x & 7)) * 3;
+      const land = { x, y, id: this.map.readUInt16LE(at) & 16383, z: this.map.readInt8(at + 2) };
+      const statics = [];
+      const offset = this.index.readInt32LE(block * 12);
+      const length = this.index.readInt32LE(block * 12 + 4);
+      if (offset >= 0 && length > 0)
+        for (let i = offset;i < offset + length; i += 7) {
+          if (this.statics[i + 2] === (x & 7) && this.statics[i + 3] === (y & 7))
+            statics.push({ x, y, id: this.statics.readUInt16LE(i), z: this.statics.readInt8(i + 4) });
+        }
+      const value = { land, statics };
+      const slot = this.cacheCursor++ & 32767;
+      const evicted = this.cacheKeys[slot];
+      if (this.cache.size >= 32768 && evicted !== undefined)
+        this.cache.delete(evicted);
+      this.cacheKeys[slot] = key;
+      this.cache.set(key, value);
+      return value;
+    }
+    stand(x, y, fromZ, from) {
+      const z = this.standingZ(x, y, fromZ, from);
+      return z === undefined ? null : { x, y, z };
+    }
+    standingZ(x, y, fromZ, from) {
+      const cell = this.cell(x, y);
+      const a = cell.land.z, b = this.cell(x + 1, y).land.z, c = this.cell(x, y + 1).land.z, d = this.cell(x + 1, y + 1).land.z;
+      const landZ = Math.floor(Math.abs(a - d) > Math.abs(b - c) ? (b + c) / 2 : (a + d) / 2);
+      let startTop = fromZ;
+      if (from) {
+        const a = this.cell(from.x, from.y).land.z, b = this.cell(from.x + 1, from.y).land.z;
+        const c = this.cell(from.x, from.y + 1).land.z, d = this.cell(from.x + 1, from.y + 1).land.z;
+        const average = Math.floor(Math.abs(a - d) > Math.abs(b - c) ? (b + c) / 2 : (a + d) / 2);
+        if (fromZ >= average && !(this.tile(this.cell(from.x, from.y).land.id).flags & 192))
+          startTop = Math.max(fromZ, a, b, c, d);
+        for (const item of this.cell(from.x, from.y).statics) {
+          const tile = this.tile(item.id, true);
+          const top = item.z + (tile.flags & 1024 ? Math.floor(tile.height / 2) : tile.height);
+          if (tile.flags & TileFlag.Surface && top <= fromZ)
+            startTop = Math.max(startTop, item.z + tile.height);
+        }
+      }
+      let best;
+      let delta = Infinity;
+      const landAllowed = !(this.tile(cell.land.id).flags & 192);
+      for (let index = landAllowed ? -1 : 0;index < cell.statics.length; index++) {
+        let z;
+        let stepTop;
+        if (index < 0) {
+          z = landZ;
+          stepTop = Math.min(a, b, c, d);
+        } else {
+          const item = cell.statics[index];
+          if (!item)
+            continue;
+          const tile = this.tile(item.id, true);
+          if ((tile.flags & 576) !== 512)
+            continue;
+          z = item.z + (tile.flags & 1024 ? Math.floor(tile.height / 2) : tile.height);
+          stepTop = item.z + (tile.flags & 1024 ? 0 : tile.height);
+        }
+        if (stepTop > startTop + 2 || z < fromZ - 16 || Math.abs(z - fromZ) >= delta)
+          continue;
+        let clear = true;
+        for (const item of cell.statics) {
+          const tile = this.tile(item.id, true);
+          const height = tile.flags & 1024 ? Math.floor(tile.height / 2) : tile.height;
+          if (tile.flags & 576 && item.z < z + 16 && item.z + height > z) {
+            clear = false;
+            break;
+          }
+        }
+        if (clear) {
+          best = z;
+          delta = Math.abs(z - fromZ);
+        }
+      }
+      return best;
+    }
+    path(start, goal, range = 0, blocked = new Set, targetZ) {
+      this.localSearch ??= new RouteSearch;
+      return this.localSearch.run(this, { start, goal, range, blocked: [...blocked], targetZ }).path;
+    }
+    async pathAsync(start, goal, range = 0, blocked = new Set, targetZ, signal, partial = false) {
+      const request = (wide) => PathPool.get(this.directory, this.facet, this.sharedBuffers()).run({
+        start,
+        goal,
+        range,
+        blocked: [...blocked, ...teleporterTiles.filter((tile) => tile !== `${goal.x},${goal.y}`)],
+        penalties: troubleCells(),
+        penaltyCost: tuning.trouble.stepCost,
+        targetZ,
+        partial,
+        wide,
+        seed: routeSeed(goal)
+      }, signal);
+      let result = await request(false);
+      const end = result.path?.at(-1);
+      const short = !end || Math.max(Math.abs(end.x - goal.x), Math.abs(end.y - goal.y)) > range;
+      if (short && result.exhausted && result.expanded >= 8192 && !signal?.aborted) {
+        const wide = await request(true);
+        if (wide.path)
+          result = wide;
+      }
+      return result.path;
+    }
+  };
+});
+
+// src/path-worker.ts
+import { parentPort, workerData } from "worker_threads";
+
+// src/path-corridors.ts
+init_direct_route();
+init_path_search();
+
+// src/route-waypoints.ts
+import { readFileSync as readFileSync2 } from "fs";
+var publicRoutes = JSON.parse(readFileSync2(new URL("../locations/route-corridors.json", import.meta.url), "utf8"));
+var distance2 = (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+var point = (row) => ({ x: row[0] ?? 0, y: row[1] ?? 0, z: row[2] ?? 0 });
+
+class RouteWaypoints {
+  corridors;
+  constructor(corridors = publicRoutes.corridors) {
+    this.corridors = corridors;
+  }
+  run(terrain, request, search, cancelled) {
+    if (!request.partial || terrain.facet !== publicRoutes.facet)
+      return null;
+    const remaining = distance2(request.start, request.goal);
+    const choices = [];
+    for (const corridor of this.corridors) {
+      for (const rows of corridor.both ? [corridor.points, [...corridor.points].reverse()] : [corridor.points]) {
+        const last = rows.at(-1);
+        if (!last)
+          continue;
+        const end = point(last);
+        if (distance2(end, request.goal) >= remaining - 8)
+          continue;
+        for (let i = 0;i < rows.length - 1; i++) {
+          const row = rows[i];
+          const following = rows[i + 1];
+          if (!row || !following)
+            continue;
+          const join = point(row);
+          const d = distance2(request.start, join);
+          if (d > 128)
+            continue;
+          choices.push({ join, next: point(following), score: d + distance2(end, request.goal) * 0.05 });
+        }
+      }
+    }
+    choices.sort((a, b) => a.score - b.score);
+    for (const choice of choices.slice(0, 4)) {
+      if (cancelled())
+        return null;
+      const joined = search.run(terrain, { ...request, goal: choice.join, range: 0, targetZ: choice.join.z, partial: false }, cancelled);
+      if (!joined.path)
+        continue;
+      const start = joined.path.at(-1) ?? request.start;
+      const onward = search.run(terrain, { ...request, start, goal: choice.next, range: 0, targetZ: choice.next.z, partial: false }, cancelled);
+      if (onward.path?.length)
+        return {
+          ...onward,
+          path: [...joined.path, ...onward.path],
+          expanded: joined.expanded + onward.expanded,
+          elapsedMs: joined.elapsedMs + onward.elapsedMs
+        };
+    }
+    return null;
+  }
+}
+
+// src/path-corridors.ts
+class RouteCorridors {
+  routes = new Map;
+  search = new RouteSearch;
+  waypoints = new RouteWaypoints;
+  run(terrain, request, cancelled) {
+    const began = performance.now();
+    const blocked = new Set(request.blocked);
+    const distance = (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+    const key = `${request.goal.x},${request.goal.y},${request.range},${request.targetZ ?? ""}`;
+    if (distance(request.start, request.goal) > 96) {
+      const local = this.waypoints.run(terrain, request, this.search, cancelled);
+      if (local)
+        return { ...local, elapsedMs: performance.now() - began };
+    }
+    const direct = directRoute(terrain, request.start, request.goal, request.range, blocked, request.targetZ, 1024);
+    if (direct && distance(direct.at(-1) ?? request.start, request.goal) <= request.range)
+      return { path: direct, expanded: 0, exhausted: false, elapsedMs: performance.now() - began };
+    const corridor = this.routes.get(key);
+    if (corridor && !corridor.some((p) => blocked.has(`${p.x},${p.y}`))) {
+      let index = -1;
+      let best = 49;
+      for (const [i, point] of corridor.entries()) {
+        const d = distance(request.start, point);
+        if (d <= best) {
+          best = d;
+          index = i;
+        }
+      }
+      const join = corridor[index];
+      if (join) {
+        const prefix = this.search.run(terrain, { ...request, goal: join, targetZ: join.z, range: 0, partial: false }, cancelled);
+        if (prefix.path)
+          return {
+            ...prefix,
+            path: [...prefix.path, ...corridor.slice(index + 1)],
+            elapsedMs: performance.now() - began
+          };
+      }
+    }
+    const result = this.search.run(terrain, request, cancelled);
+    const end = result.path?.at(-1) ?? request.start;
+    if (result.path && result.path.length > 64 && distance(end, request.goal) <= request.range && (request.targetZ === undefined || Math.abs(end.z - request.targetZ) <= 8)) {
+      const oldest = this.routes.keys().next().value;
+      if (this.routes.size >= 64 && oldest !== undefined)
+        this.routes.delete(oldest);
+      this.routes.set(key, result.path);
+    }
+    return result;
+  }
+}
+
+// src/path-worker.ts
+init_terrain();
+var terrain = Terrain.shared(workerData.directory, workerData.facet, workerData.buffers);
+var search = new RouteCorridors;
+parentPort?.on("message", (message) => {
+  const cancelled = new Int32Array(message.cancellation);
+  try {
+    const result = search.run(terrain, message.request, () => Atomics.load(cancelled, 0) !== 0);
+    parentPort?.postMessage({ id: message.id, result });
+  } catch (error) {
+    parentPort?.postMessage({ id: message.id, error: error instanceof Error ? error.message : String(error) });
+  }
+});