1681-engine 0.5.8 → 0.5.9

package/dist/engine/Engine.js

@@ -1,9 +1,11 @@
-import { TextureSource as d, Application as l } from "pixi.js";
+import { TextureSource as d, Application as p } from "pixi.js";
 import { Stage as o } from "../core/Stage.js";
-import { TextureRegistry as p } from "../core/TextureRegistry.js";
+import { TextureRegistry as l } from "../core/TextureRegistry.js";
 import { patchPixi as m } from "../core/pixiPatches.js";
 import { EventBus as f } from "../events/EventBus.js";
-import { FixedLoop as g } from "./FixedLoop.js";
+import { followReducedMotion as g } from "../platform/reducedMotion.js";
+import { FixedLoop as w } from "./FixedLoop.js";
+import { HiddenPause as k } from "./HiddenPause.js";
 import { SceneManager as v } from "./SceneManager.js";
 class x extends o {
   constructor(e, t, r) {
@@ -14,11 +16,11 @@ class x extends o {
     this.tick(e, t);
   }
 }
-class c {
+class u {
   constructor(e, t, r) {
-    this.app = e, this.loop = new g(r.hz === void 0 ? {} : { hz: r.hz }), this.stage = new x(e, t, (s, n) => this.tick(s, n));
-    const i = this.stage.cameras.main;
-    i.setZoom(r.zoom ?? 1), i.defaultZoom = i.zoom, i.roundPixels = r.pixelPerfect === !0, i.resolution = e.renderer.resolution, this.scenes = new v(this), o.onCaught = (s, n) => this.events.emit("error", { where: s, error: n }), e.ticker.add(this.onTick);
+    this.app = e, this.loop = new w(r.hz === void 0 ? {} : { hz: r.hz }), this.stage = new x(e, t, (i, n) => this.tick(i, n));
+    const s = this.stage.cameras.main;
+    s.setZoom(r.zoom ?? 1), s.defaultZoom = s.zoom, s.roundPixels = r.pixelPerfect === !0, s.resolution = e.renderer.resolution, this.scenes = new v(this), o.onCaught = (i, n) => this.events.emit("error", { where: i, error: n }), e.ticker.add(this.onTick), r.pauseWhenHidden === !0 && this.unwatch.push(this.hiddenPause.watch()), r.followReducedMotion === !0 && this.unwatch.push(g());
   }
   app;
   stage;
@@ -27,21 +29,24 @@ class c {
   events = new f();
   running = !0;
   destroyed = !1;
+  /** Pauses through the loop's own switch, so a hidden tab never counts as the game's own pause (`forget`). */
+  hiddenPause = this.makeHiddenPause();
+  unwatch = [];
   onTick = (e) => this.stage.frame(e.deltaMS);
   static async create(e) {
     const t = e.pixelPerfect === !0;
     d.defaultOptions.scaleMode = t ? "nearest" : "linear";
     const r = t ? 1 : e.resolution ?? Math.min(2, typeof devicePixelRatio == "number" ? devicePixelRatio : 1);
     m();
-    const i = new l(), s = e.width === void 0 && e.height === void 0;
-    return await i.init({
-      ...s ? { resizeTo: e.parent } : { width: e.width ?? 800, height: e.height ?? 600 },
+    const s = new p(), i = e.width === void 0 && e.height === void 0;
+    return await s.init({
+      ...i ? { resizeTo: e.parent } : { width: e.width ?? 800, height: e.height ?? 600 },
       background: e.background ?? "#000000",
       antialias: !t,
       resolution: r,
       autoDensity: !0,
       preference: e.preference ?? "webgl"
-    }), e.parent.appendChild(i.canvas), new c(i, e.textures ?? new p(), e);
+    }), e.parent.appendChild(s.canvas), new u(s, e.textures ?? new l(), e);
   }
   /** The scene that updates now, if any. */
   get scene() {
@@ -49,9 +54,25 @@ class c {
   }
   /** Stops simulating and drawing; the canvas keeps its last frame. */
   pause() {
-    this.running && (this.running = !1, this.app.ticker.stop());
+    this.hiddenPause.forget(), this.pauseLoop();
   }
   resume() {
+    this.hiddenPause.forget(), this.resumeLoop();
+  }
+  makeHiddenPause() {
+    const e = this;
+    return new k({
+      get paused() {
+        return !e.running;
+      },
+      pause: () => e.pauseLoop(),
+      resume: () => e.resumeLoop()
+    });
+  }
+  pauseLoop() {
+    this.running && (this.running = !1, this.app.ticker.stop());
+  }
+  resumeLoop() {
     this.running || this.destroyed || (this.running = !0, this.loop.reset(), this.app.ticker.start());
   }
   get paused() {
@@ -63,20 +84,23 @@ class c {
   }
   /** Leaves every scene, removes the canvas and frees the renderer. */
   async destroy() {
-    this.destroyed || (this.destroyed = !0, await this.scenes.clear(), this.app.ticker.remove(this.onTick), o.onCaught && (o.onCaught = null), this.stage.destroy(), this.events.clear(), this.app.destroy({ removeView: !0 }, { children: !0 }));
+    if (!this.destroyed) {
+      this.destroyed = !0;
+      for (const e of this.unwatch.splice(0)) e();
+      await this.scenes.clear(), this.app.ticker.remove(this.onTick), o.onCaught && (o.onCaught = null), this.stage.destroy(), this.events.clear(), this.app.destroy({ removeView: !0 }, { children: !0 });
+    }
   }
   tick(e, t) {
     const r = this.scenes.current;
     if (r) {
-      const i = (h, u) => this.reportError(`system ${h.name}`, u), s = this.loop.stepSeconds, n = this.loop.advance(t, () => {
-        r.world.run("fixed", { dt: s, now: e, alpha: 0 }, i), r.fixedUpdate(s);
+      const s = (h, c) => this.reportError(`system ${h.name}`, c), i = this.loop.stepSeconds, n = this.loop.advance(t, () => {
+        r.world.run("fixed", { dt: i, now: e, alpha: 0 }, s), r.fixedUpdate(i);
       }), a = t / 1e3;
-      r.world.run("frame", { dt: a, now: e, alpha: n }, i), r.update(a, n);
+      r.world.run("frame", { dt: a, now: e, alpha: n }, s), r.update(a, n);
     }
     this.events.emit("frame", { now: e, dt: t / 1e3 });
   }
 }
 export {
-  c as Engine
+  u as Engine
 };
-//# sourceMappingURL=Engine.js.map

package/dist/engine/FixedLoop.js

@@ -34,4 +34,3 @@ class i {
 export {
   i as FixedLoop
 };
-//# sourceMappingURL=FixedLoop.js.map

package/dist/engine/HiddenPause.js

@@ -0,0 +1,27 @@
+class s {
+  constructor(e) {
+    this.target = e;
+  }
+  target;
+  pausedByUs = !1;
+  hidden() {
+    this.target.paused || (this.target.pause(), this.pausedByUs = !0);
+  }
+  shown() {
+    this.pausedByUs && (this.pausedByUs = !1, this.target.paused && this.target.resume());
+  }
+  /** The game paused or resumed it itself: whatever happens next is its choice, not ours to undo. */
+  forget() {
+    this.pausedByUs = !1;
+  }
+  /** Listens to `visibilitychange` on `doc`; returns the unsubscribe. A no-op without a document. */
+  watch(e = typeof document > "u" ? null : document) {
+    if (!e) return () => {
+    };
+    const t = () => e.visibilityState === "hidden" ? this.hidden() : this.shown();
+    return e.addEventListener("visibilitychange", t), e.visibilityState === "hidden" && this.hidden(), () => e.removeEventListener("visibilitychange", t);
+  }
+}
+export {
+  s as HiddenPause
+};

package/dist/engine/Scene.js

@@ -76,4 +76,3 @@ class u {
 export {
   u as Scene
 };
-//# sourceMappingURL=Scene.js.map

package/dist/engine/SceneManager.js

@@ -70,4 +70,3 @@ class i {
 export {
   i as SceneManager
 };
-//# sourceMappingURL=SceneManager.js.map

package/dist/events/EventBus.js

@@ -39,4 +39,3 @@ class o {
 export {
   o as EventBus
 };
-//# sourceMappingURL=EventBus.js.map

package/dist/fx/Afterimages.js

@@ -0,0 +1,82 @@
+import { solidSilhouette as u, fillSolid as c } from "../core/silhouette.js";
+let g = 0;
+class x {
+  constructor(t, s = {}) {
+    this.stage = t, this.tints = s.tints?.length ? s.tints : [16777215], this.alpha = s.alpha ?? 0.6, this.durationMs = s.durationMs ?? 260, this.spacingMs = s.spacingMs ?? 22, this.endScale = s.endScale ?? 0.85, this.blend = s.blend ?? "add", this.slots = Math.max(1, s.slots ?? 16);
+  }
+  stage;
+  tints;
+  alpha;
+  durationMs;
+  spacingMs;
+  endScale;
+  blend;
+  slots;
+  prefix = `afterimage${++g}_`;
+  /** The copy wearing each ring slot's texture: it goes before its texture is painted over. */
+  slotUsers = [];
+  slot = 0;
+  fading = /* @__PURE__ */ new Set();
+  free = [];
+  lastAt = Number.NEGATIVE_INFINITY;
+  count = 0;
+  /**
+   * Leaves a copy of `body` as drawn now, standing at world (x, y) with draw order `depth` (default just behind a
+   * body sorted by `y`), unless one was left less than `spacingMs` before `now`. Answers the copy, or null when none
+   * was laid (too soon, or the frame could not be read): a caller drawing its own speed streaks between copies
+   * follows that.
+   */
+  trail(t, s, i, r, l = i - 1) {
+    if (r - this.lastAt < this.spacingMs) return null;
+    const e = this.copyOf(t, s, i);
+    return e ? (this.lastAt = r, e.setOrigin(t.originX, t.originY).setFlipX(t.flipX).setScale(t.scaleX, t.scaleY).setRotation(t.rotation).setAlpha(this.alpha).setDepth(l).setBlendMode(this.blend), e.tint = this.tints[this.count++ % this.tints.length], this.fading.add(e), this.stage.tweens.add({
+      targets: e,
+      alpha: 0,
+      scaleX: t.scaleX * this.endScale,
+      scaleY: t.scaleY * this.endScale,
+      duration: this.durationMs,
+      onComplete: () => this.spend(e)
+    }), e) : null;
+  }
+  /** Copies still fading. */
+  get active() {
+    return this.fading.size;
+  }
+  copyOf(t, s, i) {
+    const r = this.stage.textures;
+    if (!r.isLive(t.textureKey)) {
+      const f = u(t.texture);
+      if (!f) return null;
+      const n = this.free.pop(), d = n && !n.destroyed ? n.setTexture(t.textureKey, t.frameName) : this.stage.add.image(s, i, t.textureKey, t.frameName);
+      return d.texture = f, d.setPosition(s, i).setVisible(!0);
+    }
+    const l = this.slot;
+    this.slot = (l + 1) % this.slots;
+    const e = this.slotUsers[l];
+    e && !e.destroyed && (this.stage.tweens.killTweensOf(e), this.fading.delete(e), e.setVisible(!1));
+    const a = this.prefix + l;
+    r.snapshotInto(t.textureKey, t.frameName, a);
+    const h = r.get(a, "0");
+    c(h.source.resource), h.source.update();
+    const o = e && !e.destroyed ? e.setTexture(a, "0").setPosition(s, i).setVisible(!0) : this.stage.add.image(s, i, a, "0");
+    return this.slotUsers[l] = o, o;
+  }
+  /** A faded copy: hidden and kept for the next one (a ring slot's copy stays with its slot). */
+  spend(t) {
+    this.fading.delete(t), !t.destroyed && (t.setVisible(!1), !this.slotUsers.includes(t) && (this.free.length < this.slots ? this.free.push(t) : t.destroy()));
+  }
+  /** Takes every copy off the stage and frees the ring's textures. */
+  destroy() {
+    for (const t of this.fading)
+      this.stage.tweens.killTweensOf(t), this.slotUsers.includes(t) || t.destroy();
+    this.fading.clear();
+    for (const t of this.free) t.destroy();
+    this.free.length = 0;
+    for (const t of this.slotUsers) t && !t.destroyed && t.destroy();
+    for (let t = 0; t < this.slotUsers.length; t++) this.stage.textures.remove(this.prefix + t);
+    this.slotUsers.length = 0;
+  }
+}
+export {
+  x as Afterimages
+};

package/dist/fx/FloatingText.js

@@ -69,4 +69,3 @@ class m {
 export {
   m as FloatingText
 };
-//# sourceMappingURL=FloatingText.js.map

package/dist/fx/hitStop.js

@@ -25,4 +25,3 @@ export {
   h as recoilAt,
   e as recoilPx
 };
-//# sourceMappingURL=hitStop.js.map

package/dist/fx/viewCull.js

@@ -7,4 +7,3 @@ function u(o, e, n, t) {
 export {
   u as inView
 };
-//# sourceMappingURL=viewCull.js.map

package/dist/i18n/Translator.js

@@ -69,4 +69,3 @@ class c {
 export {
   c as Translator
 };
-//# sourceMappingURL=Translator.js.map

package/dist/i18n/extractStrings.js

@@ -55,4 +55,3 @@ function h(n, i) {
 export {
   v as extractStrings
 };
-//# sourceMappingURL=extractStrings.js.map

package/dist/i18n/formatMessage.js

@@ -16,4 +16,3 @@ export {
   c as formatMessage,
   f as sourceText
 };
-//# sourceMappingURL=formatMessage.js.map

package/dist/input/Actions.js

@@ -1,8 +1,9 @@
 import { parseChord as c, chordHeld as l } from "./keyChord.js";
-const f = ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "select", "start", "ls", "rs", "up", "down", "left", "right", "home"], u = ["lx", "ly", "rx", "ry"];
+import { rumblePad as f } from "./rumble.js";
+const u = ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "select", "start", "ls", "rs", "up", "down", "left", "right", "home"], w = ["lx", "ly", "rx", "ry"];
 class g {
-  constructor(t, e, i = {}) {
-    this.keyboard = t, this.bindings = new Map(Object.entries(e)), this.deadZone = i.deadZone ?? 0.25, this.gamepads = i.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
+  constructor(t, e, s = {}) {
+    this.keyboard = t, this.bindings = new Map(Object.entries(e)), this.deadZone = s.deadZone ?? 0.25, this.gamepads = s.gamepads ?? (() => typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : []);
   }
   keyboard;
   bindings;
@@ -32,15 +33,23 @@ class g {
   release(t) {
     this.virtual.delete(t);
   }
+  /**
+   * Rumbles the gamepads the actions read: every connected one, or only `padIndex` among them. Resolves true when any
+   * played; a pad without rumble is skipped silently.
+   */
+  async rumble(t, e) {
+    const s = this.gamepads(), i = e === void 0 ? s : [s[e] ?? null];
+    return (await Promise.all(i.map((r) => r ? f(r, t) : Promise.resolve(!1)))).includes(!0);
+  }
   /** Reads every device once; call at the start of each simulation step. */
   poll() {
     [this.before, this.now] = [this.now, this.before], this.now.clear();
     const t = this.gamepads().filter((e) => e !== null);
     this.claimChords();
-    for (const [e, i] of this.bindings) {
-      let s = 0;
-      for (const o of i) s = Math.max(s, this.read(o, t));
-      s > 0 && this.now.set(e, s);
+    for (const [e, s] of this.bindings) {
+      let i = 0;
+      for (const o of s) i = Math.max(i, this.read(o, t));
+      i > 0 && this.now.set(e, i);
     }
   }
   /** Held this step. */
@@ -64,8 +73,8 @@ class g {
     return this.value(e) - this.value(t);
   }
   /** A 2D direction from four actions, never longer than 1 (a diagonal is not faster). */
-  vector(t, e, i, s) {
-    const o = this.axis(t, e), r = this.axis(i, s), n = Math.hypot(o, r);
+  vector(t, e, s, i) {
+    const o = this.axis(t, e), r = this.axis(s, i), n = Math.hypot(o, r);
     return n > 1 ? [o / n, r / n] : [o, r];
   }
   /** Ends the step: the keyboard forgets its edges; virtual taps shorter than a step have now been seen. */
@@ -90,21 +99,21 @@ class g {
     if (this.keyboard)
       for (const t of this.bindings.values())
         for (const e of t) {
-          const i = this.chordOf(e);
-          i && l(i, this.keyDown) && this.claimed.add(i.code);
+          const s = this.chordOf(e);
+          s && l(s, this.keyDown) && this.claimed.add(s.code);
         }
   }
   read(t, e) {
     if (t.startsWith("touch:")) {
-      const s = t.slice(6);
-      return this.virtual.has(s) || this.virtualDown.has(s) ? 1 : 0;
+      const i = t.slice(6);
+      return this.virtual.has(i) || this.virtualDown.has(i) ? 1 : 0;
     }
     if (t.startsWith("pad:")) {
-      const s = t.slice(4);
+      const i = t.slice(4);
       let o = 0;
-      const r = s.endsWith("+") ? 1 : s.endsWith("-") ? -1 : 0;
+      const r = i.endsWith("+") ? 1 : i.endsWith("-") ? -1 : 0;
       if (r !== 0) {
-        const h = u.indexOf(s.slice(0, -1));
+        const h = w.indexOf(i.slice(0, -1));
         if (h < 0) return 0;
         for (const a of e) {
           const d = (a.axes[h] ?? 0) * r;
@@ -112,7 +121,7 @@ class g {
         }
         return Math.min(1, o);
       }
-      const n = f.indexOf(s);
+      const n = u.indexOf(i);
       if (n < 0) return 0;
       for (const h of e) {
         const a = h.buttons[n];
@@ -120,12 +129,11 @@ class g {
       }
       return Math.min(1, o);
     }
-    const i = this.chordOf(t);
-    return i ? l(i, this.keyDown) ? 1 : 0 : this.claimed.has(t) ? 0 : this.keyDown(t) ? 1 : 0;
+    const s = this.chordOf(t);
+    return s ? l(s, this.keyDown) ? 1 : 0 : this.claimed.has(t) ? 0 : this.keyDown(t) ? 1 : 0;
   }
 }
 export {
   g as Actions,
-  f as PAD_BUTTONS
+  u as PAD_BUTTONS
 };
-//# sourceMappingURL=Actions.js.map

package/dist/input/AimGesture.js

@@ -72,4 +72,3 @@ export {
   l as spotReach,
   g as spotShare
 };
-//# sourceMappingURL=AimGesture.js.map

package/dist/input/Keyboard.js

@@ -51,4 +51,3 @@ class h {
 export {
   h as Keyboard
 };
-//# sourceMappingURL=Keyboard.js.map

package/dist/input/Keymap.js

@@ -168,4 +168,3 @@ export {
   b as keymapStorage,
   u as mergeKeymap
 };
-//# sourceMappingURL=Keymap.js.map

package/dist/input/TargetLock.js

@@ -70,4 +70,3 @@ export {
   K as nearestTarget,
   y as pickTarget
 };
-//# sourceMappingURL=TargetLock.js.map

package/dist/input/aimAxis.js

@@ -5,4 +5,3 @@ function h(t) {
 export {
   h as aimAxis
 };
-//# sourceMappingURL=aimAxis.js.map

package/dist/input/keyChord.js

@@ -26,4 +26,3 @@ export {
   s as chordHeld,
   l as parseChord
 };
-//# sourceMappingURL=keyChord.js.map

package/dist/input/longPress.js

@@ -29,4 +29,3 @@ class r {
 export {
   r as LongPress
 };
-//# sourceMappingURL=longPress.js.map

package/dist/input/rumble.js

@@ -0,0 +1,42 @@
+function u(t) {
+  return t !== void 0 && t > 0 ? Math.min(1, t) : 0;
+}
+function o(t) {
+  const a = t.durationMs !== void 0 && t.durationMs > 0 ? t.durationMs : 200;
+  return {
+    duration: Math.min(5e3, a),
+    startDelay: t.startDelayMs !== void 0 && t.startDelayMs > 0 ? t.startDelayMs : 0,
+    strongMagnitude: u(t.strong),
+    weakMagnitude: u(t.weak)
+  };
+}
+function i() {
+  return typeof navigator < "u" && typeof navigator.getGamepads == "function" ? navigator.getGamepads() : [];
+}
+async function c(t, a) {
+  const r = t?.vibrationActuator;
+  if (!r || typeof r.playEffect != "function") return !1;
+  const e = o(a);
+  if (e.strongMagnitude === 0 && e.weakMagnitude === 0) return !1;
+  try {
+    const n = await r.playEffect("dual-rumble", e);
+    return n === "complete" || n === "preempted" || n === void 0;
+  } catch {
+    return !1;
+  }
+}
+function s(t, a, r = i) {
+  return c(r()[t], a);
+}
+async function d(t, a = i) {
+  try {
+    await a()[t]?.vibrationActuator?.reset?.();
+  } catch {
+  }
+}
+export {
+  s as rumble,
+  c as rumblePad,
+  o as rumbleParams,
+  d as stopRumble
+};

package/dist/input/stickAxis.js

@@ -20,4 +20,3 @@ export {
   i as stickToAxis,
   h as stickVector
 };
-//# sourceMappingURL=stickAxis.js.map

package/dist/input/touchDetect.js

@@ -4,4 +4,3 @@ function e(r) {
 export {
   e as detectTouch
 };
-//# sourceMappingURL=touchDetect.js.map

package/dist/light/LightLayer.js

@@ -81,4 +81,3 @@ class x {
 export {
   x as LightLayer
 };
-//# sourceMappingURL=LightLayer.js.map

package/dist/nav/MinHeap.js

@@ -36,4 +36,3 @@ class c {
 export {
   c as MinHeap
 };
-//# sourceMappingURL=MinHeap.js.map

package/dist/nav/findPath.js

@@ -75,4 +75,3 @@ export {
   U as octile,
   V as reachedCount
 };
-//# sourceMappingURL=findPath.js.map

package/dist/nav/navGrid.js

@@ -33,4 +33,3 @@ export {
   T as navGridFromCollision,
   w as nearWallCost
 };
-//# sourceMappingURL=navGrid.js.map

package/dist/nav/nearestOpen.js

@@ -16,4 +16,3 @@ function c(s, f, i, u = 12, l = (e, t) => b(s, e, t)) {
 export {
   c as nearestOpen
 };
-//# sourceMappingURL=nearestOpen.js.map

package/dist/nav/straightenPath.js

@@ -48,4 +48,3 @@ export {
   D as simplifyPath,
   C as straightenPath
 };
-//# sourceMappingURL=straightenPath.js.map

package/dist/net/Connection.js

@@ -1,13 +1,16 @@
-import { EventBus as o } from "../events/EventBus.js";
+import { EventBus as i } from "../events/EventBus.js";
+import { onAppResume as o } from "../platform/appResume.js";
 import { noteServerTime as r } from "./serverClock.js";
-import { decodeSnapshotFrame as h } from "./snapshotCodec.js";
-class m {
+import { decodeSnapshotFrame as n } from "./snapshotCodec.js";
+import { shouldReconnect as h, reconnectDelay as c } from "./reconnect.js";
+const l = 4408;
+class d {
   constructor(e, t = {}) {
     this.url = e, this.options = t;
   }
   url;
   options;
-  events = new o();
+  events = new i();
   /** The last measured round trip, ms. */
   rtt = 0;
   socket = null;
@@ -16,6 +19,8 @@ class m {
   attempt = 0;
   pingTimer = null;
   retryTimer = null;
+  probeTimer = null;
+  stopResume = null;
   get open() {
     return this.socket?.readyState === 1;
   }
@@ -27,13 +32,8 @@ class m {
     return t.binaryType = "arraybuffer", this.socket = t, t.onopen = () => {
       this.attempt = 0, this.send({ t: "hello", data: this.options.hello?.() }), this.ping(), this.pingTimer = setInterval(() => this.ping(), this.options.pingMs ?? 1e3), this.events.emit("open", void 0);
     }, t.onmessage = (s) => this.receive(s.data), t.onclose = (s) => {
-      this.pingTimer && clearInterval(this.pingTimer), this.pingTimer = null, this.socket = null;
-      const i = !this.closedByUs && this.options.reconnect !== !1;
-      if (this.events.emit("close", { code: s.code, reason: s.reason, willRetry: i }), i) {
-        const n = Math.min(this.options.maxBackoffMs ?? 1e4, 250 * 2 ** this.attempt++);
-        this.retryTimer = setTimeout(() => this.connect(), n);
-      }
-    }, this;
+      (this.socket === t || this.socket === null) && this.closed(s.code, s.reason);
+    }, (this.options.resumeProbeMs ?? 0) > 0 && !this.stopResume && (this.stopResume = (this.options.onResume ?? o)(() => this.probe())), this;
   }
   /** Sends a message now (dropped while closed: input is resent by the prediction's own state, not by the socket). */
   send(e) {
@@ -48,7 +48,30 @@ class m {
     this.batch && (this.send({ t: "input", seq: this.batch.seq, steps: this.batch.steps }), this.batch = null);
   }
   close() {
-    this.closedByUs = !0, this.retryTimer && clearTimeout(this.retryTimer), this.pingTimer && clearInterval(this.pingTimer), this.socket?.close(), this.socket = null;
+    this.closedByUs = !0, this.retryTimer && clearTimeout(this.retryTimer), this.pingTimer && clearInterval(this.pingTimer), this.clearProbe(), this.stopResume?.(), this.stopResume = null, this.socket?.close(), this.socket = null;
+  }
+  /** The socket is gone (closed, or given up on): report it and reconnect unless told not to. */
+  closed(e, t) {
+    this.pingTimer && clearInterval(this.pingTimer), this.pingTimer = null, this.clearProbe(), this.socket = null;
+    const s = h(e, { closedByUs: this.closedByUs, reconnect: this.options.reconnect, fatalCloseCodes: this.options.fatalCloseCodes });
+    this.events.emit("close", { code: e, reason: t, willRetry: s }), s && (this.retryTimer = setTimeout(() => this.connect(), c(this.attempt++, this.options.maxBackoffMs)));
+  }
+  /** Back from the background: a pong within `resumeProbeMs` proves the socket alive, none drops it. */
+  probe() {
+    const e = this.socket;
+    !e || e.readyState !== 1 || this.probeTimer || (this.probeTimer = setTimeout(() => {
+      if (this.probeTimer = null, this.socket === e) {
+        e.onopen = e.onmessage = e.onclose = null;
+        try {
+          e.close();
+        } catch {
+        }
+        this.closed(l, "no answer after resume");
+      }
+    }, this.options.resumeProbeMs), this.ping());
+  }
+  clearProbe() {
+    this.probeTimer && clearTimeout(this.probeTimer), this.probeTimer = null;
   }
   ping() {
     this.send({ t: "ping", c: Date.now() });
@@ -56,7 +79,7 @@ class m {
   receive(e) {
     let t;
     try {
-      t = typeof e == "string" ? JSON.parse(e) : h(e);
+      t = typeof e == "string" ? JSON.parse(e) : n(e);
     } catch (s) {
       console.error("[net] could not read a message", s);
       return;
@@ -64,7 +87,7 @@ class m {
     switch (t.t) {
       case "pong": {
         const s = t;
-        this.rtt = Date.now() - s.c, r(s.st, this.rtt);
+        this.clearProbe(), this.rtt = Date.now() - s.c, r(s.st, this.rtt);
         return;
       }
       case "welcome":
@@ -79,6 +102,6 @@ class m {
   }
 }
 export {
-  m as Connection
+  l as CLOSE_NO_ANSWER,
+  d as Connection
 };
-//# sourceMappingURL=Connection.js.map

package/dist/net/InterpolationBuffer.js

@@ -54,4 +54,3 @@ function f(e, s, a) {
 export {
   x as InterpolationBuffer
 };
-//# sourceMappingURL=InterpolationBuffer.js.map

package/dist/net/PredictedMover.js

@@ -58,4 +58,3 @@ class g {
 export {
   g as PredictedMover
 };
-//# sourceMappingURL=PredictedMover.js.map

package/dist/net/Room.js

@@ -89,4 +89,3 @@ class g {
 export {
   g as Room
 };
-//# sourceMappingURL=Room.js.map

package/dist/net/RoomHost.js

@@ -98,4 +98,3 @@ class p {
 export {
   p as RoomHost
 };
-//# sourceMappingURL=RoomHost.js.map