@wenathlan/stealthhead 0.0.0-stage → 2.0.117

package/tests/onboardingstate.test.ts

@@ -0,0 +1,62 @@
+// # onboardingstate.test — the pure contract of the seen flags: the host
+//   validation of the platform base (https only, public hosts only) and the
+//   seen-wins stage merge the accessor and the pages share. runnable with
+//   vitest: pnpm vitest run tests/onboardingstate.test.ts
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { hostallowed, mergeStage } from "../onboardingstate.ts";
+
+describe("onboarding state", () => {
+  it("accepts public https bases", () => {
+    assert.equal(hostallowed("https://gateway.wenathlan.dev"), true);
+    assert.equal(hostallowed("https://gateway.wenathlan.dev/"), true);
+    assert.equal(hostallowed("https://stealthhead.example.com:8443"), true);
+  });
+
+  it("refuses plaintext, localhost, loopback and every private or reserved range", () => {
+    const refused = [
+      "http://gateway.wenathlan.dev",
+      "https://localhost",
+      "https://localhost:8787",
+      "https://app.localhost",
+      "https://box.local",
+      "https://service.internal",
+      "https://127.0.0.1",
+      "https://0.0.0.0",
+      "https://10.0.0.9",
+      "https://172.16.0.1",
+      "https://172.31.255.255",
+      "https://192.168.1.4",
+      "https://169.254.10.10",
+      "https://100.64.0.1",
+      "https://192.0.2.7",
+      "https://198.51.100.7",
+      "https://203.0.113.9",
+      "https://[::1]",
+      "https://[::ffff:127.0.0.1]",
+      "https://[fd00::1]",
+      "https://[fe80::1]",
+      "not a url",
+      "",
+    ];
+    for (const base of refused) assert.equal(hostallowed(base), false, base);
+  });
+
+  it("merges stages seen-wins — a stage never unsees", () => {
+    const fresh = { introseen: false, onboardingseen: false };
+    assert.deepEqual(mergeStage(fresh, "intro"), { introseen: true, onboardingseen: false });
+    assert.deepEqual(mergeStage(fresh, "onboarding"), { introseen: false, onboardingseen: true });
+    const half = { introseen: true, onboardingseen: false };
+    assert.deepEqual(mergeStage(half, "onboarding"), { introseen: true, onboardingseen: true });
+    assert.deepEqual(mergeStage(mergeStage(half, "onboarding"), "intro"), {
+      introseen: true,
+      onboardingseen: true,
+    });
+  });
+
+  it("never mutates the state it merges", () => {
+    const state = { introseen: false, onboardingseen: false };
+    mergeStage(state, "intro");
+    assert.deepEqual(state, { introseen: false, onboardingseen: false });
+  });
+});

package/tests/physics.test.ts

@@ -0,0 +1,185 @@
+// # physics.test — honest unit tests for the deterministic physics kernel,
+// runnable with the vitest runner:
+//   pnpm test
+// Every case feeds plain structs and checks the exact replayable output —
+// no fixtures from the DOM, no randomness, no mocks.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  aabb,
+  aabbcenter,
+  add,
+  applydrag,
+  type Body,
+  boxboxhit,
+  closestpoint,
+  createworld,
+  DEFAULTGRAVITY,
+  distance,
+  dot,
+  fixedsteps,
+  length,
+  normalize,
+  type PhysWorld,
+  scale,
+  sphereboxhit,
+  spherespherehit,
+  stepbody,
+  stepprojectile,
+  sweepbox,
+  vec3,
+} from "../physics.ts";
+
+const UNIT = aabb(vec3(0, 0, 0), vec3(1, 1, 1));
+
+/** one free body resting at the origin with standard tuning. */
+function bodyat(x: number, y: number, z: number, velocity = vec3(0, 0, 0)): Body {
+  return { id: "b1", position: vec3(x, y, z), velocity, invmass: 1, restitution: 0.5, friction: 0 };
+}
+
+/** an open arena from the origin to 100 on every axis. */
+function arena(): PhysWorld {
+  return createworld(vec3(0, 0, 0), vec3(100, 100, 100));
+}
+
+describe("vector kernel", () => {
+  it("adds, scales, dots, measures and normalizes without mutating", () => {
+    const v = vec3(3, 0, 4);
+    assert.deepEqual(add(v, vec3(1, 2, 3)), { x: 4, y: 2, z: 7 });
+    assert.deepEqual(scale(v, 2), { x: 6, y: 0, z: 8 });
+    assert.equal(dot(v, vec3(1, 0, 0)), 3);
+    assert.equal(length(v), 5);
+    const unit = normalize(v);
+    assert.ok(Math.abs(unit.x - 0.6) < 1e-9);
+    assert.equal(unit.y, 0);
+    assert.ok(Math.abs(unit.z - 0.8) < 1e-9);
+    assert.equal(length(v), 5);
+  });
+
+  it("keeps normalize total on the zero vector", () => {
+    assert.deepEqual(normalize(vec3(0, 0, 0)), { x: 0, y: 0, z: 0 });
+    assert.equal(distance(vec3(1, 2, 3), vec3(4, 6, 3)), 5);
+  });
+});
+
+describe("shape queries", () => {
+  it("builds boxes, centers them and finds closest points", () => {
+    const box = aabb(vec3(0, 0, 0), vec3(4, 2, 6));
+    assert.deepEqual(aabbcenter(box), { x: 2, y: 1, z: 3 });
+    assert.deepEqual(closestpoint(box, vec3(5, 1, 3)), { x: 4, y: 1, z: 3 });
+    assert.deepEqual(closestpoint(UNIT, vec3(0.5, 2, -1)), { x: 0.5, y: 1, z: 0 });
+  });
+
+  it("answers sphere, sphere-sphere and box-box overlaps", () => {
+    assert.equal(sphereboxhit({ center: vec3(2, 0.5, 0.5), radius: 1.5 }, UNIT), true);
+    assert.equal(sphereboxhit({ center: vec3(2, 0.5, 0.5), radius: 0.5 }, UNIT), false);
+    assert.equal(spherespherehit({ center: vec3(0, 0, 0), radius: 1 }, { center: vec3(2, 0, 0), radius: 1 }), true);
+    assert.equal(spherespherehit({ center: vec3(0, 0, 0), radius: 0.9 }, { center: vec3(2, 0, 0), radius: 1 }), false);
+    assert.equal(boxboxhit(UNIT, aabb(vec3(0.5, 0.5, 0.5), vec3(2, 2, 2))), true);
+    assert.equal(boxboxhit(UNIT, aabb(vec3(2, 2, 2), vec3(3, 3, 3))), false);
+  });
+
+  it("sweeps a box and reports the entry fraction or null", () => {
+    const wall = aabb(vec3(4, 0, 0), vec3(5, 1, 1));
+    assert.equal(sweepbox(UNIT, vec3(4, 0, 0), wall), 0.75);
+    assert.equal(sweepbox(UNIT, vec3(3, 0, 0), wall), 1);
+    assert.equal(sweepbox(UNIT, vec3(4, 0, 0), aabb(vec3(4, 5, 0), vec3(5, 6, 1))), null);
+    assert.equal(sweepbox(UNIT, vec3(0, 0, 0), aabb(vec3(0.2, 0.2, 0.2), vec3(0.8, 0.8, 0.8))), 0);
+    assert.equal(sweepbox(UNIT, vec3(0, 0, 0), aabb(vec3(5, 5, 5), vec3(6, 6, 6))), null);
+  });
+});
+
+describe("integration", () => {
+  it("applies gravity and bounces on the arena floor with restitution", () => {
+    const next = stepbody(
+      bodyat(0, 0, 0, vec3(1, 0, 0)),
+      1,
+      vec3(0, -10, 0),
+      aabb(vec3(-10, 0, -10), vec3(10, 10, 10)),
+    );
+    assert.deepEqual(next.position, { x: 1, y: 0, z: 0 });
+    assert.equal(next.velocity.x, 1);
+    assert.equal(next.velocity.y, 5);
+  });
+
+  it("damps horizontal velocity by friction and respects invmass 0", () => {
+    const grounded = { ...bodyat(0, 0, 0, vec3(2, 0, 0)), friction: 1 };
+    const next = stepbody(grounded, 1, vec3(0, -10, 0), aabb(vec3(-10, 0, -10), vec3(10, 10, 10)));
+    assert.equal(next.velocity.x, 0);
+    const pinned: Body = { ...bodyat(3, 3, 3, vec3(1, 1, 1)), invmass: 0 };
+    const still = stepbody(pinned, 1, vec3(0, -10, 0), aabb(vec3(-10, 0, -10), vec3(10, 10, 10)));
+    assert.deepEqual(still.position, { x: 3, y: 3, z: 3 });
+    assert.deepEqual(still.velocity, { x: 1, y: 1, z: 1 });
+  });
+
+  it("decays velocity through linear drag", () => {
+    assert.deepEqual(applydrag(vec3(10, 0, 0), 0.5, 0.2), { x: 9, y: 0, z: 0 });
+    assert.deepEqual(applydrag(vec3(10, 0, 0), 1, 2), { x: 0, y: 0, z: 0 });
+  });
+});
+
+describe("projectiles", () => {
+  it("flies with gravity and drag and reports no hit in open air", () => {
+    const step = stepprojectile(
+      { id: "p1", position: vec3(0, 50, 50), velocity: vec3(10, 0, 0), gravity: -10, drag: 0 },
+      1,
+      arena(),
+    );
+    assert.deepEqual(step.projectile.position, { x: 10, y: 40, z: 50 });
+    assert.equal(step.hit, null);
+    const dragged = stepprojectile(
+      { id: "p2", position: vec3(0, 50, 50), velocity: vec3(10, 0, 0), gravity: 0, drag: 0.5 },
+      1,
+      arena(),
+    );
+    assert.equal(dragged.projectile.velocity.x, 5);
+  });
+
+  it("stops at the arena bounds as a world hit", () => {
+    const step = stepprojectile(
+      { id: "p3", position: vec3(99, 50, 50), velocity: vec3(10, 0, 0), gravity: -10, drag: 0 },
+      1,
+      arena(),
+    );
+    assert.equal(step.hit?.kind, "world");
+    assert.deepEqual(step.hit?.at, { x: 100, y: 40, z: 50 });
+  });
+
+  it("stops at the first swept body hit and names it", () => {
+    const world = arena();
+    world.bodies.push({ ...bodyat(5, 50, 50), id: "crate" });
+    const step = stepprojectile(
+      { id: "p4", position: vec3(0, 50, 50), velocity: vec3(10, 0, 0), gravity: 0, drag: 0 },
+      1,
+      world,
+    );
+    assert.equal(step.hit?.kind, "body");
+    assert.equal(step.hit?.id, "crate");
+    assert.deepEqual(step.hit?.at, { x: 5, y: 50, z: 50 });
+  });
+});
+
+describe("fixed-step loop", () => {
+  it("converts frame deltas into whole steps plus a carried remainder", () => {
+    const first = fixedsteps(0, 0.05, 0.02);
+    assert.equal(first.steps, 2);
+    assert.ok(Math.abs(first.remainder - 0.01) < 1e-9);
+    const second = fixedsteps(0.01, 0.02, 0.02);
+    assert.equal(second.steps, 1);
+    assert.ok(Math.abs(second.remainder - 0.01) < 1e-9);
+  });
+
+  it("caps catch-up steps so a stall never spirals", () => {
+    const capped = fixedsteps(0, 1, 0.02, 3);
+    assert.equal(capped.steps, 3);
+    assert.ok(Math.abs(capped.remainder - 0.94) < 1e-9);
+  });
+
+  it("bootstraps the empty arena with the default gravity", () => {
+    const world = createworld(vec3(0, 0, 0), vec3(10, 10, 10));
+    assert.deepEqual(world.gravity, DEFAULTGRAVITY);
+    assert.equal(world.bodies.length, 0);
+    assert.equal(world.projectiles.length, 0);
+    assert.equal(dot(DEFAULTGRAVITY, vec3(0, 1, 0)), -19.6);
+  });
+});

package/tests/rankingladder.test.ts

@@ -0,0 +1,162 @@
+// # rankingladder.test — honest unit tests for the elo ladder arithmetic,
+// runnable with the vitest runner:
+//   pnpm test
+// Every k table, ceiling and floor arrives as a parameter — the tests pass
+// their own season config, exactly as a caller would.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  applydelta,
+  expectedscore,
+  kfactor,
+  type LadderOptions,
+  laddererror,
+  projectedrating,
+  rankduel,
+  ratingdelta,
+} from "../rankingladder.ts";
+
+/** the season config the tests play with: 32/24/16 bands like the classic tables. */
+const SEASON: LadderOptions = {
+  ktable: [
+    { minrating: 0, maxrating: 2100, k: 32 },
+    { minrating: 2100, maxrating: 2400, k: 24 },
+    { minrating: 2400, maxrating: Number.POSITIVE_INFINITY, k: 16 },
+  ],
+  maxdelta: 40,
+  floorrating: 100,
+  scale: 400,
+};
+
+describe("ranking ladder expected score", () => {
+  it("answers one half for equal ratings", () => {
+    assert.equal(expectedscore(1500, 1500, SEASON), 0.5);
+  });
+
+  it("answers the classic 0.909 for a 400 point favorite", () => {
+    const expected = expectedscore(1900, 1500, SEASON);
+    assert.ok(Math.abs(expected - 0.909) < 0.001, `expected ~0.909, got ${expected}`);
+    assert.ok(expectedscore(1500, 1900, SEASON) < 0.1);
+  });
+
+  it("mirrors around one half", () => {
+    const up = expectedscore(1700, 1500, SEASON);
+    const down = expectedscore(1500, 1700, SEASON);
+    assert.ok(Math.abs(up + down - 1) < 1e-9);
+  });
+
+  it("refuses non finite ratings", () => {
+    assert.throws(
+      () => expectedscore(Number.NaN, 1500, SEASON),
+      (error: unknown) => {
+        assert.ok(error instanceof laddererror);
+        assert.equal(error.code, "bad-rating");
+        return true;
+      },
+    );
+  });
+});
+
+describe("ranking ladder k factor", () => {
+  it("picks the band the rating falls into", () => {
+    assert.equal(kfactor(1500, SEASON.ktable), 32);
+    assert.equal(kfactor(2200, SEASON.ktable), 24);
+    assert.equal(kfactor(2500, SEASON.ktable), 16);
+    assert.equal(kfactor(2399.9, SEASON.ktable), 24);
+  });
+
+  it("serves a different table when the season passes one", () => {
+    assert.equal(kfactor(1500, [{ minrating: 0, maxrating: Number.POSITIVE_INFINITY, k: 10 }]), 10);
+  });
+
+  it("refuses an empty table, a non positive k and an uncovered rating", () => {
+    assert.throws(
+      () => kfactor(1500, []),
+      (error: unknown) => {
+        assert.ok(error instanceof laddererror);
+        assert.equal(error.code, "bad-ktable");
+        return true;
+      },
+    );
+    assert.throws(() => kfactor(1500, [{ minrating: 0, maxrating: 1000, k: 32 }]), laddererror);
+    assert.throws(() => kfactor(1500, [{ minrating: 0, maxrating: Number.POSITIVE_INFINITY, k: 0 }]), laddererror);
+  });
+});
+
+describe("ranking ladder deltas", () => {
+  it("rewards a win by k * (1 - expected) and penalizes the mirrored loss", () => {
+    const win = ratingdelta(1500, 1500, "win", SEASON);
+    assert.equal(win, 16); // k 32, expected 0.5
+    const loss = ratingdelta(1500, 1500, "loss", SEASON);
+    assert.equal(loss, -16);
+  });
+
+  it("pays less to the favorite and more to the underdog", () => {
+    const favorite = ratingdelta(1900, 1500, "win", SEASON);
+    const underdog = ratingdelta(1500, 1900, "win", SEASON);
+    assert.ok(favorite > 0 && favorite < 4, `favorite should earn little, got ${favorite}`);
+    assert.ok(underdog > 28, `underdog should earn a lot, got ${underdog}`);
+  });
+
+  it("scales with the k table the caller passes", () => {
+    const low = ratingdelta(1500, 1500, "win", {
+      ...SEASON,
+      ktable: [{ minrating: 0, maxrating: Number.POSITIVE_INFINITY, k: 8 }],
+    });
+    assert.equal(low, 4);
+  });
+
+  it("clamps the delta to the season ceiling", () => {
+    const clamped = ratingdelta(1500, 3500, "win", { ...SEASON, maxdelta: 20 });
+    assert.ok(clamped <= 20, `expected the clamp to hold, got ${clamped}`);
+    const floored = ratingdelta(3500, 900, "loss", { ...SEASON, maxdelta: 20 });
+    assert.ok(floored >= -20, `expected the clamp to hold, got ${floored}`);
+  });
+
+  it("grades a draw as half a win against an equal opponent", () => {
+    assert.equal(ratingdelta(1500, 1500, "draw", SEASON), 0);
+    assert.ok(ratingdelta(1500, 1900, "draw", SEASON) > 0);
+  });
+
+  it("refuses an unknown outcome", () => {
+    assert.throws(
+      () => ratingdelta(1500, 1500, "forfeit" as "win", SEASON),
+      (error: unknown) => {
+        assert.ok(error instanceof laddererror);
+        assert.equal(error.code, "bad-outcome");
+        return true;
+      },
+    );
+  });
+});
+
+describe("ranking ladder duels and projections", () => {
+  it("applies the floor when a big loss sinks the rating", () => {
+    assert.equal(applydelta(120, -90, 100), 100);
+    assert.equal(applydelta(1500, -30, 100), 1470);
+  });
+
+  it("rates both sides of a duel with mirrored deltas", () => {
+    const result = rankduel({ id: "vanta.k", rating: 1600 }, { id: "coldsnap", rating: 1400 }, "win", SEASON);
+    assert.ok(result.player.delta > 0 && result.opponent.delta < 0);
+    assert.ok(Math.abs(result.expected - 0.76) < 0.001, `expected ~0.760, got ${result.expected}`);
+    assert.equal(result.player.rating, 1600 + result.player.delta);
+    assert.equal(result.opponent.rating, 1400 + result.opponent.delta);
+  });
+
+  it("compounds a winning streak through the running rating", () => {
+    const opponents = [1500, 1500, 1500, 1500];
+    const after = projectedrating(
+      1500,
+      opponents.map((opponent) => ({ opponent, outcome: "win" as const })),
+      SEASON,
+    );
+    assert.ok(after > 1550, `a streak should compound, got ${after}`);
+    const recovered = projectedrating(
+      after,
+      opponents.map((opponent) => ({ opponent, outcome: "loss" as const })),
+      SEASON,
+    );
+    assert.ok(recovered < after);
+  });
+});

package/tests/spawner.test.ts

@@ -0,0 +1,210 @@
+// # spawner.test — honest unit tests for the spawn selection and respawn
+// pacing, runnable with the vitest runner:
+//   pnpm test
+// The prng is seeded, the seed rows are the real catalog, and every case
+// checks exact replayable output — no mocks, no randomness, no dom.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  buildwave,
+  campscore,
+  DEFAULTSPAWNCONFIG,
+  distance,
+  duewaves,
+  filterbymindistance,
+  isprotected,
+  makerng,
+  nearestdistance,
+  pickspawn,
+  protectionuntil,
+  respawnwait,
+  SPAWNSEED,
+  type SpawnPick,
+  type SpawnQuery,
+  scorepoints,
+  selectspawn,
+  shortlist,
+  spawnpointsformap,
+  spawnpointsforteam,
+  withdeath,
+} from "../spawner.ts";
+
+/** a plain spawn query over steelhead dam for team ember. */
+function damquery(extra: Partial<SpawnQuery> = {}): SpawnQuery {
+  return { map: "steelhead dam", team: "ember", enemies: [], occupied: [], deaths: [], tick: 0, ...extra };
+}
+
+describe("seeded prng", () => {
+  it("replays the same sequence for the same seed", () => {
+    const a = makerng(7);
+    const b = makerng(7);
+    const seqa = [a(), a(), a()];
+    const seqb = [b(), b(), b()];
+    assert.deepEqual(seqa, seqb);
+    assert.equal(makerng(7)(), seqa[0]);
+  });
+
+  it("stays inside [0, 1) and diverges across seeds", () => {
+    const a = makerng(1);
+    const b = makerng(2);
+    for (let i = 0; i < 16; i++) {
+      const va = a();
+      assert.ok(va >= 0 && va < 1);
+      assert.notEqual(va, b());
+    }
+  });
+});
+
+describe("catalog filters", () => {
+  it("filters points by map and by team with neutral flow", () => {
+    assert.equal(spawnpointsformap(SPAWNSEED, "steelhead dam").length, 4);
+    assert.equal(spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember").length, 2);
+    assert.equal(spawnpointsforteam(SPAWNSEED, "rift yard", "tide").length, 4);
+    assert.equal(spawnpointsformap(SPAWNSEED, "no such map").length, 0);
+  });
+
+  it("drops points inside the hard radius of blocked positions", () => {
+    const dam = spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember");
+    const kept = filterbymindistance(dam, [dam[0].position], DEFAULTSPAWNCONFIG.mindistance);
+    assert.deepEqual(
+      kept.map((point) => point.id),
+      ["sd-e2"],
+    );
+    assert.equal(filterbymindistance(dam, [], 12).length, 2);
+  });
+
+  it("measures distances and the nearest of a cloud", () => {
+    assert.ok(Math.abs(distance({ x: 0, y: 0, z: 0 }, { x: 3, y: 0, z: 4 }) - 5) < 1e-9);
+    assert.equal(nearestdistance({ x: 0, y: 0, z: 0 }, []), Infinity);
+    assert.equal(
+      nearestdistance({ x: 0, y: 0, z: 0 }, [
+        { x: 3, y: 0, z: 4 },
+        { x: 1, y: 0, z: 0 },
+      ]),
+      1,
+    );
+  });
+});
+
+describe("scoring and lottery", () => {
+  it("decays camp pressure by the half-life inside the radius", () => {
+    const point = SPAWNSEED[0];
+    assert.equal(campscore(point, [], 0, DEFAULTSPAWNCONFIG), 0);
+    const fresh = campscore(point, [{ position: point.position, tick: 400 }], 400, DEFAULTSPAWNCONFIG);
+    assert.equal(fresh, 1);
+    const aged = campscore(point, [{ position: point.position, tick: 0 }], 400, DEFAULTSPAWNCONFIG);
+    assert.ok(Math.abs(aged - 0.5) < 1e-9);
+    const far = campscore(point, [{ position: { x: 500, y: 0, z: 500 }, tick: 400 }], 400, DEFAULTSPAWNCONFIG);
+    assert.equal(far, 0);
+  });
+
+  it("scores full weight when enemies are far and sorts descending", () => {
+    const picks = scorepoints(spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember"), damquery(), DEFAULTSPAWNCONFIG);
+    assert.equal(picks.length, 2);
+    assert.equal(picks[0].score, 1);
+    assert.equal(picks[1].score, 0.8);
+    assert.equal(picks[0].point.id, "sd-e1");
+  });
+
+  it("discounts the score when an enemy camped the point", () => {
+    const point = SPAWNSEED[0];
+    const query = damquery({ deaths: [{ position: point.position, tick: 100 }], tick: 100 });
+    const picks = scorepoints([point], query, DEFAULTSPAWNCONFIG);
+    assert.ok(picks[0].score < 0.01);
+  });
+
+  it("shortlists and runs the score-proportional lottery", () => {
+    const picks: SpawnPick[] = [
+      { point: SPAWNSEED[0], score: 1 },
+      { point: SPAWNSEED[2], score: 3 },
+      { point: SPAWNSEED[4], score: 0.5 },
+    ];
+    assert.equal(shortlist(picks, 2).length, 2);
+    assert.equal(pickspawn(picks, () => 0.1).point.id, "sd-e1");
+    assert.equal(pickspawn(picks, () => 0.5).point.id, "sd-t1");
+    assert.equal(pickspawn(picks, () => 0.999).point.id, "ch-e1");
+  });
+});
+
+describe("the spawn pipeline", () => {
+  it("picks deterministically for the same seed", () => {
+    const first = selectspawn(SPAWNSEED, damquery(), DEFAULTSPAWNCONFIG, makerng(7));
+    const second = selectspawn(SPAWNSEED, damquery(), DEFAULTSPAWNCONFIG, makerng(7));
+    assert.ok(first);
+    assert.equal(first.point.id, second?.point.id);
+    assert.ok(SPAWNSEED.some((point) => point.id === first.point.id));
+  });
+
+  it("returns null when safety or stacking filters wipe the map", () => {
+    const dam = spawnpointsforteam(SPAWNSEED, "steelhead dam", "ember");
+    const stacked = selectspawn(
+      SPAWNSEED,
+      damquery({ occupied: dam.map((point) => point.position) }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.equal(stacked, null);
+    const unsafe = selectspawn(
+      SPAWNSEED,
+      damquery({ enemies: dam.map((point) => point.position) }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.equal(unsafe, null);
+  });
+
+  it("hard-filters enemies near a point even when others survive", () => {
+    const near = SPAWNSEED[0].position;
+    const pick = selectspawn(
+      SPAWNSEED,
+      damquery({ enemies: [{ x: near.x + 5, y: 0, z: near.z }] }),
+      DEFAULTSPAWNCONFIG,
+      makerng(7),
+    );
+    assert.ok(pick);
+    assert.notEqual(pick.point.id, "sd-e1");
+  });
+});
+
+describe("respawn pacing", () => {
+  it("prunes death marks older than the window", () => {
+    const marks = withdeath(
+      [
+        { position: { x: 0, y: 0, z: 0 }, tick: 0 },
+        { position: { x: 1, y: 0, z: 0 }, tick: 500 },
+      ],
+      { position: { x: 2, y: 0, z: 0 }, tick: 600 },
+      400,
+    );
+    assert.equal(marks.length, 2);
+    assert.equal(marks[marks.length - 1].tick, 600);
+  });
+
+  it("escalates the respawn wait 1.5x per death and caps it", () => {
+    assert.equal(respawnwait(1, DEFAULTSPAWNCONFIG), 50);
+    assert.equal(respawnwait(3, DEFAULTSPAWNCONFIG), 113);
+    assert.equal(respawnwait(10, DEFAULTSPAWNCONFIG), 400);
+  });
+
+  it("grants and expires spawn protection", () => {
+    assert.equal(protectionuntil(100, DEFAULTSPAWNCONFIG), 160);
+    assert.equal(isprotected(protectionuntil(100, DEFAULTSPAWNCONFIG), 159), true);
+    assert.equal(isprotected(protectionuntil(100, DEFAULTSPAWNCONFIG), 160), false);
+  });
+});
+
+describe("wave scheduling", () => {
+  it("schedules waves on the interval grid", () => {
+    const config = { waves: 3, countperwave: 5, intervalticks: 100 };
+    assert.deepEqual(buildwave(config, 2, 50), { wave: 2, startat: 150, count: 5 });
+    assert.deepEqual(buildwave(config, 1, 50), { wave: 1, startat: 50, count: 5 });
+  });
+
+  it("lists only the waves due inside the window", () => {
+    const config = { waves: 3, countperwave: 5, intervalticks: 100 };
+    assert.equal(duewaves(config, 0, 250).length, 3);
+    assert.equal(duewaves(config, 0, 150).length, 2);
+    assert.equal(duewaves(config, 0, 0).length, 1);
+    assert.deepEqual(duewaves(config, 1000, 0), []);
+  });
+});