1681-engine 0.0.0-stage → 0.5.8

package/dist/debug/DebugOverlay.js

@@ -0,0 +1,94 @@
+import { Container as c, Sprite as d, Texture as f, Graphics as p, Text as w } from "pixi.js";
+import { DrawCallCounter as x } from "./DrawCallCounter.js";
+import { ErrorLog as m } from "./ErrorLog.js";
+import { FrameStats as u } from "./FrameStats.js";
+import { inspectWorld as g } from "./inspectWorld.js";
+const h = 180, o = 40, y = 250;
+class F {
+  constructor(t, s = {}) {
+    this.engine = t, this.options = s, this.errors = new m(s.errors ?? 8), this.draws = new x(t.app.renderer), this.back.tint = 0, this.back.alpha = 0.7, this.graph.position.set(6, 6), this.text.position.set(6, o + 12), this.panel.addChild(this.back, this.graph, this.text), this.boxLayer.addChild(this.boxes), this.cleanup.push(t.events.on("error", ({ where: n, error: a }) => this.errors.add(n, a)));
+    const e = s.target ?? window, i = s.key ?? "Backquote", r = (n) => {
+      const a = n;
+      a.code === i && (a.preventDefault(), a.repeat || this.toggle());
+    };
+    e.addEventListener("keydown", r), this.cleanup.push(() => e.removeEventListener("keydown", r));
+  }
+  engine;
+  options;
+  errors;
+  stats = new u(h / 2);
+  panel = new c();
+  back = new d(f.WHITE);
+  graph = new p();
+  text = new w({ text: "", style: { fontFamily: "monospace", fontSize: 11, fill: 15263976, lineHeight: 13 } });
+  boxes = new p();
+  boxLayer = new c();
+  draws;
+  cleanup = [];
+  offFrame = null;
+  lastText = -1 / 0;
+  drawCalls = 0;
+  shown = !1;
+  drawBox = (t, s, e, i, r = 4259680) => {
+    this.boxes.rect(t, s, e, i).stroke({ width: 1, color: r, alpha: 0.9, pixelLine: !0 });
+  };
+  drawLine = (t, s, e, i, r = 4259680) => {
+    this.boxes.moveTo(t, s).lineTo(e, i).stroke({ width: 1, color: r, alpha: 0.9, pixelLine: !0 });
+  };
+  get visible() {
+    return this.shown;
+  }
+  toggle() {
+    this.shown ? this.hide() : this.show();
+  }
+  show() {
+    if (this.shown) return;
+    this.shown = !0;
+    const t = this.engine.stage;
+    t.screen.addChild(this.boxLayer, this.panel), t.cameras.main.follow(this.boxLayer), this.draws.install(), this.draws.take(), this.stats.clear(), this.lastText = -1 / 0, this.offFrame = this.engine.events.on("frame", ({ now: s, dt: e }) => this.frame(s, e));
+  }
+  hide() {
+    this.shown && (this.shown = !1, this.offFrame?.(), this.offFrame = null, this.draws.uninstall(), this.engine.stage.cameras.main.unfollow(this.boxLayer), this.panel.removeFromParent(), this.boxLayer.removeFromParent(), this.boxes.clear());
+  }
+  destroy() {
+    this.hide();
+    for (const t of this.cleanup.splice(0)) t();
+    this.panel.destroy({ children: !0 }), this.boxLayer.destroy({ children: !0 });
+  }
+  frame(t, s) {
+    this.stats.push(s * 1e3), this.drawCalls = this.draws.take(), this.paintGraph(), this.boxes.clear(), this.options.colliders && this.options.colliders(this.drawBox, this.drawLine), t - this.lastText >= y && (this.lastText = t, this.paintText());
+  }
+  paintGraph() {
+    const t = this.graph.clear();
+    t.rect(0, 0, h, o).fill({ color: 2105376 });
+    for (const e of [1e3 / 60, 1e3 / 30]) t.rect(0, o - e / 50 * o, h, 1).fill({ color: 5263440 });
+    const s = this.stats.count;
+    for (let e = 0; e < s; e++) {
+      const i = this.stats.at(e), r = Math.max(1, Math.min(o, Math.round(i / 50 * o))), n = i > 1e3 / 30 ? 16732240 : i > 1e3 / 55 ? 16760896 : 6348912;
+      t.rect(e * 2, o - r, 2, r).fill({ color: n });
+    }
+  }
+  paintText() {
+    const t = this.engine.app.renderer, s = this.options.world ? this.options.world() : this.engine.scene?.world, e = [
+      `${this.stats.fps.toFixed(0)} fps  avg ${this.stats.average.toFixed(1)} ms  max ${this.stats.max.toFixed(1)} ms`,
+      `draw calls ${this.draws.supported ? this.drawCalls : "n/a"}  textures ${b(t)}`,
+      `entities ${s ? s.size : "-"}  scene ${this.engine.scene?.constructor.name ?? "-"}`
+    ];
+    if (s)
+      for (const i of g(s, this.options.components, this.options.inspectLimit ?? 12)) e.push(`#${i.entity} ${i.components.join(" | ")}`);
+    if (this.errors.entries.length) {
+      e.push("errors:");
+      for (const i of this.errors.entries) e.push(`${i.count > 1 ? `${i.count}x ` : ""}${i.where}: ${i.message}`.slice(0, 120));
+    }
+    this.text.text = e.join(`
+`), this.back.width = Math.max(h + 12, Math.ceil(this.text.width) + 12), this.back.height = Math.ceil(this.text.y + this.text.height + 6);
+  }
+}
+function b(l) {
+  const t = l.texture.managedTextures;
+  return t ? t.length : "n/a";
+}
+export {
+  F as DebugOverlay
+};
+//# sourceMappingURL=DebugOverlay.js.map

package/dist/debug/DebugOverlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebugOverlay.js","sources":["../../src/debug/DebugOverlay.ts"],"sourcesContent":["import { Container, Graphics, Sprite, Text, Texture } from 'pixi.js';\nimport type { Renderer } from 'pixi.js';\nimport type { ComponentType, World } from '../ecs/World';\nimport type { Engine } from '../engine/Engine';\nimport { DrawCallCounter } from './DrawCallCounter';\nimport { ErrorLog } from './ErrorLog';\nimport { FrameStats } from './FrameStats';\nimport { inspectWorld } from './inspectWorld';\n\n/** Draws one box in world coordinates (a hurtbox, a wall, a trigger), in `color` (default green). */\nexport type BoxDrawer = (x: number, y: number, width: number, height: number, color?: number) => void;\n\n/** Draws one line in world coordinates (a turned collider's edge, a ray), in `color` (default green). */\nexport type LineDrawer = (x0: number, y0: number, x1: number, y1: number, color?: number) => void;\n\nexport interface DebugOverlayOptions {\n  /**\n   * `KeyboardEvent.code` that shows and hides it (default 'Backquote'). The key's own browser action is prevented\n   * (F3 would open the find bar, F12 the developer tools).\n   */\n  key?: string;\n  /** The world to count and inspect (default the current scene's). */\n  world?: () => World | undefined;\n  /** Component types the inspector lists; none, and it lists every entity with all it holds. */\n  components?: readonly ComponentType<unknown>[];\n  /** Entities listed at most (default 12). */\n  inspectLimit?: number;\n  /** Called every shown frame to draw collision boxes (and lines: turned shapes, rays). */\n  colliders?: (draw: BoxDrawer, line: LineDrawer) => void;\n  /** Errors kept (default 8). */\n  errors?: number;\n  /** Where the key is listened for (default `window`). */\n  target?: Window | HTMLElement;\n}\n\nconst GRAPH_W = 180;\nconst GRAPH_H = 40;\n/** Text is rebuilt this often: a Pixi `Text` re-rasterises on every change, which would cost more than it measures. */\nconst TEXT_MS = 250;\n\n/**\n * A developer overlay toggled by a key: FPS with a frame-time graph, draw calls and textures, the entity count, a\n * list of entities and their components, collision boxes, and the last errors the frame guard caught.\n *\n * Hidden, it costs nothing per frame: nothing is drawn or listened to but the key and the engine's `error` event\n * (so faults from before it was opened are still listed). Shown, it rides the engine's `frame` event.\n */\nexport class DebugOverlay {\n  readonly errors: ErrorLog;\n  private readonly stats = new FrameStats(GRAPH_W / 2);\n  private readonly panel = new Container();\n  private readonly back = new Sprite(Texture.WHITE);\n  private readonly graph = new Graphics();\n  private readonly text = new Text({ text: '', style: { fontFamily: 'monospace', fontSize: 11, fill: 0xe8e8e8, lineHeight: 13 } });\n  private readonly boxes = new Graphics();\n  private readonly boxLayer = new Container();\n  private readonly draws: DrawCallCounter;\n  private readonly cleanup: (() => void)[] = [];\n  private offFrame: (() => void) | null = null;\n  private lastText = -Infinity;\n  private drawCalls = 0;\n  private shown = false;\n  private readonly drawBox: BoxDrawer = (x, y, w, h, color = 0x40ff60) => {\n    this.boxes.rect(x, y, w, h).stroke({ width: 1, color, alpha: 0.9, pixelLine: true });\n  };\n\n  private readonly drawLine: LineDrawer = (x0, y0, x1, y1, color = 0x40ff60) => {\n    this.boxes.moveTo(x0, y0).lineTo(x1, y1).stroke({ width: 1, color, alpha: 0.9, pixelLine: true });\n  };\n\n  constructor(\n    private readonly engine: Engine,\n    private readonly options: DebugOverlayOptions = {},\n  ) {\n    this.errors = new ErrorLog(options.errors ?? 8);\n    this.draws = new DrawCallCounter(engine.app.renderer);\n    this.back.tint = 0x000000;\n    this.back.alpha = 0.7;\n    this.graph.position.set(6, 6);\n    this.text.position.set(6, GRAPH_H + 12);\n    this.panel.addChild(this.back, this.graph, this.text);\n    this.boxLayer.addChild(this.boxes);\n    this.cleanup.push(engine.events.on('error', ({ where, error }) => this.errors.add(where, error)));\n    const target = options.target ?? window;\n    const key = options.key ?? 'Backquote';\n    const onKey = (e: Event) => {\n      const k = e as KeyboardEvent;\n      if (k.code !== key) return;\n      // the overlay's key, not the browser's: F3 opened find-in-page over the game\n      k.preventDefault();\n      if (!k.repeat) this.toggle();\n    };\n    target.addEventListener('keydown', onKey);\n    this.cleanup.push(() => target.removeEventListener('keydown', onKey));\n  }\n\n  get visible(): boolean {\n    return this.shown;\n  }\n\n  toggle(): void {\n    if (this.shown) this.hide();\n    else this.show();\n  }\n\n  show(): void {\n    if (this.shown) return;\n    this.shown = true;\n    const stage = this.engine.stage;\n    stage.screen.addChild(this.boxLayer, this.panel);\n    stage.cameras.main.follow(this.boxLayer);\n    this.draws.install();\n    this.draws.take();\n    this.stats.clear();\n    this.lastText = -Infinity;\n    this.offFrame = this.engine.events.on('frame', ({ now, dt }) => this.frame(now, dt));\n  }\n\n  hide(): void {\n    if (!this.shown) return;\n    this.shown = false;\n    this.offFrame?.();\n    this.offFrame = null;\n    this.draws.uninstall();\n    this.engine.stage.cameras.main.unfollow(this.boxLayer);\n    this.panel.removeFromParent();\n    this.boxLayer.removeFromParent();\n    this.boxes.clear();\n  }\n\n  destroy(): void {\n    this.hide();\n    for (const fn of this.cleanup.splice(0)) fn();\n    this.panel.destroy({ children: true });\n    this.boxLayer.destroy({ children: true });\n  }\n\n  private frame(now: number, dt: number): void {\n    this.stats.push(dt * 1000);\n    // counted while the previous frame rendered: the 'frame' event comes before this frame's render\n    this.drawCalls = this.draws.take();\n    this.paintGraph();\n    this.boxes.clear();\n    if (this.options.colliders) this.options.colliders(this.drawBox, this.drawLine);\n    if (now - this.lastText >= TEXT_MS) {\n      this.lastText = now;\n      this.paintText();\n    }\n  }\n\n  private paintGraph(): void {\n    const g = this.graph.clear();\n    g.rect(0, 0, GRAPH_W, GRAPH_H).fill({ color: 0x202020 });\n    // 16.7 ms (60 fps) and 33.3 ms (30 fps) guides; the graph tops out at 50 ms\n    for (const ms of [1000 / 60, 1000 / 30]) g.rect(0, GRAPH_H - (ms / 50) * GRAPH_H, GRAPH_W, 1).fill({ color: 0x505050 });\n    const n = this.stats.count;\n    for (let i = 0; i < n; i++) {\n      const ms = this.stats.at(i);\n      const h = Math.max(1, Math.min(GRAPH_H, Math.round((ms / 50) * GRAPH_H)));\n      const color = ms > 1000 / 30 ? 0xff5050 : ms > 1000 / 55 ? 0xffc040 : 0x60e070;\n      g.rect(i * 2, GRAPH_H - h, 2, h).fill({ color });\n    }\n  }\n\n  private paintText(): void {\n    const renderer = this.engine.app.renderer;\n    const world = this.options.world ? this.options.world() : this.engine.scene?.world;\n    const lines: string[] = [\n      `${this.stats.fps.toFixed(0)} fps  avg ${this.stats.average.toFixed(1)} ms  max ${this.stats.max.toFixed(1)} ms`,\n      `draw calls ${this.draws.supported ? this.drawCalls : 'n/a'}  textures ${textureCount(renderer)}`,\n      `entities ${world ? world.size : '-'}  scene ${this.engine.scene?.constructor.name ?? '-'}`,\n    ];\n    if (world) {\n      for (const row of inspectWorld(world, this.options.components, this.options.inspectLimit ?? 12)) lines.push(`#${row.entity} ${row.components.join(' | ')}`);\n    }\n    if (this.errors.entries.length) {\n      lines.push('errors:');\n      for (const e of this.errors.entries) lines.push(`${e.count > 1 ? `${e.count}x ` : ''}${e.where}: ${e.message}`.slice(0, 120));\n    }\n    this.text.text = lines.join('\\n');\n    this.back.width = Math.max(GRAPH_W + 12, Math.ceil(this.text.width) + 12);\n    this.back.height = Math.ceil(this.text.y + this.text.height + 6);\n  }\n}\n\n/** Textures the renderer holds on the GPU; the WebGL and WebGPU systems expose it, the canvas fallback does not. */\nfunction textureCount(renderer: Renderer): number | string {\n  const managed = (renderer.texture as { managedTextures?: readonly unknown[] }).managedTextures;\n  return managed ? managed.length : 'n/a';\n}\n"],"names":["GRAPH_W","GRAPH_H","TEXT_MS","DebugOverlay","engine","options","ErrorLog","DrawCallCounter","where","error","target","key","onKey","e","k","FrameStats","Container","Sprite","Texture","Graphics","Text","x","y","w","h","color","x0","y0","x1","y1","stage","now","dt","fn","g","ms","n","i","renderer","world","lines","textureCount","row","inspectWorld","managed"],"mappings":"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"}

package/dist/debug/DrawCallCounter.js

@@ -0,0 +1,41 @@
+const c = ["drawElements", "drawArrays", "drawElementsInstanced", "drawArraysInstanced"];
+class i {
+  constructor(r) {
+    this.renderer = r;
+  }
+  renderer;
+  /** Draw calls since the last `take`. */
+  calls = 0;
+  restore = null;
+  /** Whether this renderer can be counted (WebGL). */
+  get supported() {
+    return o(this.renderer) !== null;
+  }
+  install() {
+    const r = o(this.renderer);
+    if (!r || this.restore) return;
+    const n = r, l = [];
+    for (const t of c) {
+      const e = n[t];
+      typeof e == "function" && (l.push([t, e]), n[t] = (...a) => (this.calls++, e.apply(r, a)));
+    }
+    this.restore = () => {
+      for (const [t, e] of l) n[t] = e;
+    };
+  }
+  uninstall() {
+    this.restore?.(), this.restore = null;
+  }
+  /** Draw calls since the last call, and starts counting again. */
+  take() {
+    const r = this.calls;
+    return this.calls = 0, r;
+  }
+}
+function o(s) {
+  return s.gl ?? null;
+}
+export {
+  i as DrawCallCounter
+};
+//# sourceMappingURL=DrawCallCounter.js.map

package/dist/debug/DrawCallCounter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrawCallCounter.js","sources":["../../src/debug/DrawCallCounter.ts"],"sourcesContent":["import type { Renderer } from 'pixi.js';\n\nconst DRAW_CALLS = ['drawElements', 'drawArrays', 'drawElementsInstanced', 'drawArraysInstanced'] as const;\n\n/**\n * Counts WebGL draw calls by wrapping the context's draw functions while it is installed, since Pixi 8 keeps no\n * count of its own. Installed only while the debug overlay is open, so a closed overlay costs nothing; on WebGPU\n * (no `gl`) it counts nothing and says so.\n */\nexport class DrawCallCounter {\n  /** Draw calls since the last `take`. */\n  private calls = 0;\n  private restore: (() => void) | null = null;\n\n  constructor(private readonly renderer: Renderer) {}\n\n  /** Whether this renderer can be counted (WebGL). */\n  get supported(): boolean {\n    return glOf(this.renderer) !== null;\n  }\n\n  install(): void {\n    const gl = glOf(this.renderer);\n    if (!gl || this.restore) return;\n    const target = gl as unknown as Record<string, unknown>;\n    const saved: [string, unknown][] = [];\n    for (const name of DRAW_CALLS) {\n      const fn = target[name];\n      if (typeof fn !== 'function') continue;\n      saved.push([name, fn]);\n      target[name] = (...args: unknown[]) => {\n        this.calls++;\n        return (fn as (...a: unknown[]) => unknown).apply(gl, args);\n      };\n    }\n    this.restore = () => {\n      for (const [name, fn] of saved) target[name] = fn;\n    };\n  }\n\n  uninstall(): void {\n    this.restore?.();\n    this.restore = null;\n  }\n\n  /** Draw calls since the last call, and starts counting again. */\n  take(): number {\n    const n = this.calls;\n    this.calls = 0;\n    return n;\n  }\n}\n\nfunction glOf(renderer: Renderer): WebGL2RenderingContext | WebGLRenderingContext | null {\n  const gl = (renderer as unknown as { gl?: WebGL2RenderingContext | WebGLRenderingContext }).gl;\n  return gl ?? null;\n}\n"],"names":["DRAW_CALLS","DrawCallCounter","renderer","glOf","gl","target","saved","name","fn","args","n"],"mappings":"AAEA,MAAMA,IAAa,CAAC,gBAAgB,cAAc,yBAAyB,qBAAqB;AAOzF,MAAMC,EAAgB;AAAA,EAK3B,YAA6BC,GAAoB;AAApB,SAAA,WAAAA;AAAA,EAAqB;AAAA,EAArB;AAAA;AAAA,EAHrB,QAAQ;AAAA,EACR,UAA+B;AAAA;AAAA,EAKvC,IAAI,YAAqB;AACvB,WAAOC,EAAK,KAAK,QAAQ,MAAM;AAAA,EACjC;AAAA,EAEA,UAAgB;AACd,UAAMC,IAAKD,EAAK,KAAK,QAAQ;AAC7B,QAAI,CAACC,KAAM,KAAK,QAAS;AACzB,UAAMC,IAASD,GACTE,IAA6B,CAAA;AACnC,eAAWC,KAAQP,GAAY;AAC7B,YAAMQ,IAAKH,EAAOE,CAAI;AACtB,MAAI,OAAOC,KAAO,eAClBF,EAAM,KAAK,CAACC,GAAMC,CAAE,CAAC,GACrBH,EAAOE,CAAI,IAAI,IAAIE,OACjB,KAAK,SACGD,EAAoC,MAAMJ,GAAIK,CAAI;AAAA,IAE9D;AACA,SAAK,UAAU,MAAM;AACnB,iBAAW,CAACF,GAAMC,CAAE,KAAKF,EAAO,CAAAD,EAAOE,CAAI,IAAIC;AAAA,IACjD;AAAA,EACF;AAAA,EAEA,YAAkB;AAChB,SAAK,UAAA,GACL,KAAK,UAAU;AAAA,EACjB;AAAA;AAAA,EAGA,OAAe;AACb,UAAME,IAAI,KAAK;AACf,gBAAK,QAAQ,GACNA;AAAA,EACT;AACF;AAEA,SAASP,EAAKD,GAA2E;AAEvF,SADYA,EAAgF,MAC/E;AACf;"}

package/dist/debug/ErrorLog.js

@@ -0,0 +1,22 @@
+class h {
+  constructor(s = 10) {
+    this.limit = s;
+  }
+  limit;
+  entries = [];
+  add(s, e, i = Date.now()) {
+    const n = e instanceof Error ? e.message : String(e), t = this.entries[this.entries.length - 1];
+    if (t && t.where === s && t.message === n) {
+      t.count++, t.at = i;
+      return;
+    }
+    this.entries.push({ where: s, message: n, count: 1, at: i }), this.entries.length > this.limit && this.entries.shift();
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+}
+export {
+  h as ErrorLog
+};
+//# sourceMappingURL=ErrorLog.js.map

package/dist/debug/ErrorLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorLog.js","sources":["../../src/debug/ErrorLog.ts"],"sourcesContent":["/** One fault the frame guard (or a system) caught. */\nexport interface LoggedError {\n  where: string;\n  message: string;\n  /** How many times in a row the same fault came in. */\n  count: number;\n  at: number;\n}\n\n/**\n * The last `limit` distinct faults, newest last. A fault repeating every frame is one entry with a count, not\n * sixty lines a second pushing everything else out.\n */\nexport class ErrorLog {\n  readonly entries: LoggedError[] = [];\n\n  constructor(readonly limit = 10) {}\n\n  add(where: string, error: unknown, at = Date.now()): void {\n    const message = error instanceof Error ? error.message : String(error);\n    const last = this.entries[this.entries.length - 1];\n    if (last && last.where === where && last.message === message) {\n      last.count++;\n      last.at = at;\n      return;\n    }\n    this.entries.push({ where, message, count: 1, at });\n    if (this.entries.length > this.limit) this.entries.shift();\n  }\n\n  clear(): void {\n    this.entries.length = 0;\n  }\n}\n"],"names":["ErrorLog","limit","where","error","at","message","last"],"mappings":"AAaO,MAAMA,EAAS;AAAA,EAGpB,YAAqBC,IAAQ,IAAI;AAAZ,SAAA,QAAAA;AAAA,EAAa;AAAA,EAAb;AAAA,EAFZ,UAAyB,CAAA;AAAA,EAIlC,IAAIC,GAAeC,GAAgBC,IAAK,KAAK,OAAa;AACxD,UAAMC,IAAUF,aAAiB,QAAQA,EAAM,UAAU,OAAOA,CAAK,GAC/DG,IAAO,KAAK,QAAQ,KAAK,QAAQ,SAAS,CAAC;AACjD,QAAIA,KAAQA,EAAK,UAAUJ,KAASI,EAAK,YAAYD,GAAS;AAC5D,MAAAC,EAAK,SACLA,EAAK,KAAKF;AACV;AAAA,IACF;AACA,SAAK,QAAQ,KAAK,EAAE,OAAAF,GAAO,SAAAG,GAAS,OAAO,GAAG,IAAAD,GAAI,GAC9C,KAAK,QAAQ,SAAS,KAAK,SAAO,KAAK,QAAQ,MAAA;AAAA,EACrD;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ,SAAS;AAAA,EACxB;AACF;"}

package/dist/debug/FrameStats.js

@@ -0,0 +1,42 @@
+class s {
+  constructor(t = 120) {
+    this.size = t, this.times = new Float32Array(t);
+  }
+  size;
+  times;
+  head = 0;
+  filled = 0;
+  /** Records one frame's length in ms. */
+  push(t) {
+    this.times[this.head] = t, this.head = (this.head + 1) % this.size, this.filled < this.size && this.filled++;
+  }
+  get count() {
+    return this.filled;
+  }
+  /** The `i`-th frame, oldest first. */
+  at(t) {
+    return this.times[(this.head - this.filled + t + this.size) % this.size];
+  }
+  get average() {
+    if (this.filled === 0) return 0;
+    let t = 0;
+    for (let i = 0; i < this.filled; i++) t += this.times[i];
+    return t / this.filled;
+  }
+  get max() {
+    let t = 0;
+    for (let i = 0; i < this.filled; i++) this.times[i] > t && (t = this.times[i]);
+    return t;
+  }
+  get fps() {
+    const t = this.average;
+    return t > 0 ? 1e3 / t : 0;
+  }
+  clear() {
+    this.head = 0, this.filled = 0;
+  }
+}
+export {
+  s as FrameStats
+};
+//# sourceMappingURL=FrameStats.js.map

package/dist/debug/FrameStats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameStats.js","sources":["../../src/debug/FrameStats.ts"],"sourcesContent":["/**\n * The last `size` frame times in a ring of numbers: pure, allocation-free, read by the debug overlay's graph and\n * its FPS line. Averages are over the ring, so one long frame shows in `max` without wrecking the FPS shown.\n */\nexport class FrameStats {\n  readonly times: Float32Array;\n  private head = 0;\n  private filled = 0;\n\n  constructor(readonly size = 120) {\n    this.times = new Float32Array(size);\n  }\n\n  /** Records one frame's length in ms. */\n  push(ms: number): void {\n    this.times[this.head] = ms;\n    this.head = (this.head + 1) % this.size;\n    if (this.filled < this.size) this.filled++;\n  }\n\n  get count(): number {\n    return this.filled;\n  }\n\n  /** The `i`-th frame, oldest first. */\n  at(i: number): number {\n    return this.times[(this.head - this.filled + i + this.size) % this.size]!;\n  }\n\n  get average(): number {\n    if (this.filled === 0) return 0;\n    let sum = 0;\n    for (let i = 0; i < this.filled; i++) sum += this.times[i]!;\n    return sum / this.filled;\n  }\n\n  get max(): number {\n    let m = 0;\n    for (let i = 0; i < this.filled; i++) if (this.times[i]! > m) m = this.times[i]!;\n    return m;\n  }\n\n  get fps(): number {\n    const avg = this.average;\n    return avg > 0 ? 1000 / avg : 0;\n  }\n\n  clear(): void {\n    this.head = 0;\n    this.filled = 0;\n  }\n}\n"],"names":["FrameStats","size","ms","i","sum","m","avg"],"mappings":"AAIO,MAAMA,EAAW;AAAA,EAKtB,YAAqBC,IAAO,KAAK;AAAZ,SAAA,OAAAA,GACnB,KAAK,QAAQ,IAAI,aAAaA,CAAI;AAAA,EACpC;AAAA,EAFqB;AAAA,EAJZ;AAAA,EACD,OAAO;AAAA,EACP,SAAS;AAAA;AAAA,EAOjB,KAAKC,GAAkB;AACrB,SAAK,MAAM,KAAK,IAAI,IAAIA,GACxB,KAAK,QAAQ,KAAK,OAAO,KAAK,KAAK,MAC/B,KAAK,SAAS,KAAK,QAAM,KAAK;AAAA,EACpC;AAAA,EAEA,IAAI,QAAgB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,GAAGC,GAAmB;AACpB,WAAO,KAAK,OAAO,KAAK,OAAO,KAAK,SAASA,IAAI,KAAK,QAAQ,KAAK,IAAI;AAAA,EACzE;AAAA,EAEA,IAAI,UAAkB;AACpB,QAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,QAAIC,IAAM;AACV,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,IAAK,CAAAA,KAAO,KAAK,MAAM,CAAC;AACzD,WAAOA,IAAM,KAAK;AAAA,EACpB;AAAA,EAEA,IAAI,MAAc;AAChB,QAAIC,IAAI;AACR,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,IAAK,CAAI,KAAK,MAAM,CAAC,IAAKA,MAAGA,IAAI,KAAK,MAAM,CAAC;AAC9E,WAAOA;AAAA,EACT;AAAA,EAEA,IAAI,MAAc;AAChB,UAAMC,IAAM,KAAK;AACjB,WAAOA,IAAM,IAAI,MAAOA,IAAM;AAAA,EAChC;AAAA,EAEA,QAAc;AACZ,SAAK,OAAO,GACZ,KAAK,SAAS;AAAA,EAChB;AACF;"}

package/dist/debug/inspectWorld.js

@@ -0,0 +1,29 @@
+function p(t, r, s = 20, n = 40) {
+  if (!r?.length)
+    return t.entities().slice(0, s).map((e) => ({ entity: e, components: t.componentsOf(e).map((i) => f(i, t.get(e, i), n)) }));
+  const o = /* @__PURE__ */ new Map();
+  for (const e of r)
+    t.each(e, (i, u) => {
+      let c = o.get(i);
+      if (!c) {
+        if (o.size >= s) return;
+        c = { entity: i, components: [] }, o.set(i, c);
+      }
+      c.components.push(f(e, u, n));
+    });
+  return [...o.values()].sort((e, i) => e.entity - i.entity);
+}
+function f(t, r, s) {
+  if ("fields" in t) return t.name;
+  let n;
+  try {
+    n = typeof r == "object" && r !== null ? JSON.stringify(r) : String(r);
+  } catch {
+    n = "[unprintable]";
+  }
+  return n === void 0 ? t.name : `${t.name} ${n.length > s ? n.slice(0, s - 1) + "…" : n}`;
+}
+export {
+  p as inspectWorld
+};
+//# sourceMappingURL=inspectWorld.js.map

package/dist/debug/inspectWorld.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectWorld.js","sources":["../../src/debug/inspectWorld.ts"],"sourcesContent":["import type { ComponentType, Entity, World } from '../ecs/World';\n\n/** One entity as the inspector lists it. */\nexport interface EntityRow {\n  entity: Entity;\n  /** `Name` or `Name {…}` per component it holds, of those asked about. */\n  components: string[];\n}\n\n/**\n * Lists up to `limit` entities with a short preview of each component's value: those holding any of `components`\n * when the game names some (only those shown), else every live entity with all it holds (`World.entities`,\n * `componentsOf`). For the debug overlay: it allocates, and runs a few times a second only while the overlay is open.\n */\nexport function inspectWorld(world: World, components?: readonly ComponentType<unknown>[], limit = 20, previewLength = 40): EntityRow[] {\n  if (!components?.length) {\n    return world\n      .entities()\n      .slice(0, limit)\n      .map((e) => ({ entity: e, components: world.componentsOf(e).map((type) => describe(type, world.get(e, type), previewLength)) }));\n  }\n  const rows = new Map<Entity, EntityRow>();\n  for (const type of components) {\n    world.each(type, (e, value) => {\n      let row = rows.get(e);\n      if (!row) {\n        if (rows.size >= limit) return;\n        row = { entity: e, components: [] };\n        rows.set(e, row);\n      }\n      row.components.push(describe(type, value, previewLength));\n    });\n  }\n  return [...rows.values()].sort((a, b) => a.entity - b.entity);\n}\n\nfunction describe(type: ComponentType<unknown>, value: unknown, max: number): string {\n  // a field component's stored value is only its slot: the numbers live in the world's columns\n  if ('fields' in type) return type.name;\n  let text: string;\n  try {\n    text = typeof value === 'object' && value !== null ? JSON.stringify(value) : String(value);\n  } catch {\n    text = '[unprintable]';\n  }\n  if (text === undefined) return type.name;\n  return `${type.name} ${text.length > max ? text.slice(0, max - 1) + '…' : text}`;\n}\n"],"names":["inspectWorld","world","components","limit","previewLength","type","describe","rows","e","value","row","a","b","max","text"],"mappings":"AAcO,SAASA,EAAaC,GAAcC,GAAgDC,IAAQ,IAAIC,IAAgB,IAAiB;AACtI,MAAI,CAACF,GAAY;AACf,WAAOD,EACJ,SAAA,EACA,MAAM,GAAGE,CAAK,EACd,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,YAAYF,EAAM,aAAa,CAAC,EAAE,IAAI,CAACI,MAASC,EAASD,GAAMJ,EAAM,IAAI,GAAGI,CAAI,GAAGD,CAAa,CAAC,IAAI;AAEnI,QAAMG,wBAAW,IAAA;AACjB,aAAWF,KAAQH;AACjB,IAAAD,EAAM,KAAKI,GAAM,CAACG,GAAGC,MAAU;AAC7B,UAAIC,IAAMH,EAAK,IAAIC,CAAC;AACpB,UAAI,CAACE,GAAK;AACR,YAAIH,EAAK,QAAQJ,EAAO;AACxB,QAAAO,IAAM,EAAE,QAAQF,GAAG,YAAY,CAAA,EAAC,GAChCD,EAAK,IAAIC,GAAGE,CAAG;AAAA,MACjB;AACA,MAAAA,EAAI,WAAW,KAAKJ,EAASD,GAAMI,GAAOL,CAAa,CAAC;AAAA,IAC1D,CAAC;AAEH,SAAO,CAAC,GAAGG,EAAK,OAAA,CAAQ,EAAE,KAAK,CAACI,GAAGC,MAAMD,EAAE,SAASC,EAAE,MAAM;AAC9D;AAEA,SAASN,EAASD,GAA8BI,GAAgBI,GAAqB;AAEnF,MAAI,YAAYR,EAAM,QAAOA,EAAK;AAClC,MAAIS;AACJ,MAAI;AACF,IAAAA,IAAO,OAAOL,KAAU,YAAYA,MAAU,OAAO,KAAK,UAAUA,CAAK,IAAI,OAAOA,CAAK;AAAA,EAC3F,QAAQ;AACN,IAAAK,IAAO;AAAA,EACT;AACA,SAAIA,MAAS,SAAkBT,EAAK,OAC7B,GAAGA,EAAK,IAAI,IAAIS,EAAK,SAASD,IAAMC,EAAK,MAAM,GAAGD,IAAM,CAAC,IAAI,MAAMC,CAAI;AAChF;"}

package/dist/diagnostics/ErrorDeduper.js

@@ -0,0 +1,27 @@
+class n {
+  constructor(t = 10, e = 120) {
+    this.max = t, this.keyLength = e;
+  }
+  max;
+  keyLength;
+  seen = /* @__PURE__ */ new Set();
+  /** The key to report under, or null when this error was already let through or the allowance is spent. */
+  admit(t) {
+    const e = t.slice(0, this.keyLength);
+    return this.seen.has(e) || this.seen.size >= this.max ? null : (this.seen.add(e), e);
+  }
+  /** Forgets what was let through (a new session). */
+  reset() {
+    this.seen.clear();
+  }
+}
+function i(s, t = 4, e = 600) {
+  return (s ?? "").split(`
+`).slice(0, t).join(`
+`).slice(0, e);
+}
+export {
+  n as ErrorDeduper,
+  i as trimStack
+};
+//# sourceMappingURL=ErrorDeduper.js.map

package/dist/diagnostics/ErrorDeduper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorDeduper.js","sources":["../../src/diagnostics/ErrorDeduper.ts"],"sourcesContent":["/**\n * Lets through each distinct error once, and only so many in all: a loop throwing every frame is one report, not\n * sixty a second. Errors are told apart by the first `keyLength` characters of their message.\n */\nexport class ErrorDeduper {\n  private readonly seen = new Set<string>();\n\n  constructor(\n    private readonly max = 10,\n    private readonly keyLength = 120,\n  ) {}\n\n  /** The key to report under, or null when this error was already let through or the allowance is spent. */\n  admit(message: string): string | null {\n    const key = message.slice(0, this.keyLength);\n    if (this.seen.has(key) || this.seen.size >= this.max) return null;\n    this.seen.add(key);\n    return key;\n  }\n\n  /** Forgets what was let through (a new session). */\n  reset(): void {\n    this.seen.clear();\n  }\n}\n\n/** The first `lines` lines of a stack, at most `max` characters. */\nexport function trimStack(stack: string | undefined, lines = 4, max = 600): string {\n  return (stack ?? '').split('\\n').slice(0, lines).join('\\n').slice(0, max);\n}\n"],"names":["ErrorDeduper","max","keyLength","message","key","trimStack","stack","lines"],"mappings":"AAIO,MAAMA,EAAa;AAAA,EAGxB,YACmBC,IAAM,IACNC,IAAY,KAC7B;AAFiB,SAAA,MAAAD,GACA,KAAA,YAAAC;AAAA,EAChB;AAAA,EAFgB;AAAA,EACA;AAAA,EAJF,2BAAW,IAAA;AAAA;AAAA,EAQ5B,MAAMC,GAAgC;AACpC,UAAMC,IAAMD,EAAQ,MAAM,GAAG,KAAK,SAAS;AAC3C,WAAI,KAAK,KAAK,IAAIC,CAAG,KAAK,KAAK,KAAK,QAAQ,KAAK,MAAY,QAC7D,KAAK,KAAK,IAAIA,CAAG,GACVA;AAAA,EACT;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,KAAK,MAAA;AAAA,EACZ;AACF;AAGO,SAASC,EAAUC,GAA2BC,IAAQ,GAAGN,IAAM,KAAa;AACjF,UAAQK,KAAS,IAAI,MAAM;AAAA,CAAI,EAAE,MAAM,GAAGC,CAAK,EAAE,KAAK;AAAA,CAAI,EAAE,MAAM,GAAGN,CAAG;AAC1E;"}

package/dist/diagnostics/FrameSampler.js

@@ -0,0 +1,42 @@
+import { UPDATE_PRIORITY as h } from "pixi.js";
+import { summarizeFrames as r, looksThrottled as o } from "./frameStats.js";
+class c {
+  constructor(t, s = {}) {
+    this.onSample = t, this.opts = {
+      windowMs: s.windowMs ?? 6e4,
+      hitchMs: s.hitchMs ?? 50,
+      minFrames: s.minFrames ?? 30,
+      throttledMedianMs: s.throttledMedianMs ?? 500
+    }, this.paused = s.paused ?? (() => typeof document < "u" && document.hidden), this.now = s.now ?? (() => performance.now()), this.since = this.now();
+  }
+  onSample;
+  frames = [];
+  since;
+  opts;
+  paused;
+  now;
+  /** One frame of `deltaMs`; sums the window once it is full. */
+  push(t) {
+    if (this.paused()) return;
+    this.frames.push(t);
+    const s = this.now(), e = s - this.since;
+    if (e < this.opts.windowMs) return;
+    const i = this.frames;
+    if (this.frames = [], this.since = s, i.length < this.opts.minFrames) return;
+    const n = r(i, e, this.opts.hitchMs);
+    o(n, this.opts.throttledMedianMs) || this.onSample(n);
+  }
+  /** Starts a fresh window, dropping what was counted (after a scene change, say). */
+  reset() {
+    this.frames = [], this.since = this.now();
+  }
+  /** Feeds the sampler from a Pixi ticker, after the render; returns the detach. */
+  attach(t) {
+    const s = () => this.push(t.deltaMS);
+    return t.add(s, void 0, h.UTILITY), () => t.remove(s);
+  }
+}
+export {
+  c as FrameSampler
+};
+//# sourceMappingURL=FrameSampler.js.map

package/dist/diagnostics/FrameSampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameSampler.js","sources":["../../src/diagnostics/FrameSampler.ts"],"sourcesContent":["import { type Ticker, UPDATE_PRIORITY } from 'pixi.js';\nimport { looksThrottled, summarizeFrames, type FrameSummary } from './frameStats';\n\nexport interface FrameSamplerOptions {\n  /** How long one sample spans, ms (default a minute). */\n  windowMs?: number;\n  /** A frame longer than this is a hitch, ms (default 50). */\n  hitchMs?: number;\n  /** Fewer frames than this in a window is no sample (default 30). */\n  minFrames?: number;\n  /** A window whose median frame is over this came from a throttled background window and is dropped (default 500). */\n  throttledMedianMs?: number;\n  /** Frames are not counted while this says so (default: the page is hidden). */\n  paused?: () => boolean;\n  now?: () => number;\n}\n\n/**\n * Measures how a game really runs on a player's device: each frame costs one number pushed on an array, and every\n * `windowMs` the window is summed into a `FrameSummary` handed to `onSample` — FPS, the 1% low, the 95th-percentile\n * frame, hitches. The engine sends nothing anywhere: what the game does with a sample (a readout, a report to its\n * server) is the callback's.\n */\nexport class FrameSampler {\n  private frames: number[] = [];\n  private since: number;\n  private readonly opts: Required<Omit<FrameSamplerOptions, 'paused' | 'now'>>;\n  private readonly paused: () => boolean;\n  private readonly now: () => number;\n\n  constructor(private readonly onSample: (summary: FrameSummary) => void, options: FrameSamplerOptions = {}) {\n    this.opts = {\n      windowMs: options.windowMs ?? 60_000,\n      hitchMs: options.hitchMs ?? 50,\n      minFrames: options.minFrames ?? 30,\n      throttledMedianMs: options.throttledMedianMs ?? 500,\n    };\n    this.paused = options.paused ?? (() => typeof document !== 'undefined' && document.hidden);\n    this.now = options.now ?? (() => performance.now());\n    this.since = this.now();\n  }\n\n  /** One frame of `deltaMs`; sums the window once it is full. */\n  push(deltaMs: number): void {\n    if (this.paused()) return;\n    this.frames.push(deltaMs);\n    const now = this.now();\n    const span = now - this.since;\n    if (span < this.opts.windowMs) return;\n    const sample = this.frames;\n    this.frames = [];\n    this.since = now;\n    if (sample.length < this.opts.minFrames) return;\n    const summary = summarizeFrames(sample, span, this.opts.hitchMs);\n    if (looksThrottled(summary, this.opts.throttledMedianMs)) return;\n    this.onSample(summary);\n  }\n\n  /** Starts a fresh window, dropping what was counted (after a scene change, say). */\n  reset(): void {\n    this.frames = [];\n    this.since = this.now();\n  }\n\n  /** Feeds the sampler from a Pixi ticker, after the render; returns the detach. */\n  attach(ticker: Ticker): () => void {\n    const tick = () => this.push(ticker.deltaMS);\n    ticker.add(tick, undefined, UPDATE_PRIORITY.UTILITY);\n    return () => ticker.remove(tick);\n  }\n}\n"],"names":["FrameSampler","onSample","options","deltaMs","now","span","sample","summary","summarizeFrames","looksThrottled","ticker","tick","UPDATE_PRIORITY"],"mappings":";;AAuBO,MAAMA,EAAa;AAAA,EAOxB,YAA6BC,GAA2CC,IAA+B,IAAI;AAA9E,SAAA,WAAAD,GAC3B,KAAK,OAAO;AAAA,MACV,UAAUC,EAAQ,YAAY;AAAA,MAC9B,SAASA,EAAQ,WAAW;AAAA,MAC5B,WAAWA,EAAQ,aAAa;AAAA,MAChC,mBAAmBA,EAAQ,qBAAqB;AAAA,IAAA,GAElD,KAAK,SAASA,EAAQ,WAAW,MAAM,OAAO,WAAa,OAAe,SAAS,SACnF,KAAK,MAAMA,EAAQ,QAAQ,MAAM,YAAY,QAC7C,KAAK,QAAQ,KAAK,IAAA;AAAA,EACpB;AAAA,EAV6B;AAAA,EANrB,SAAmB,CAAA;AAAA,EACnB;AAAA,EACS;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAejB,KAAKC,GAAuB;AAC1B,QAAI,KAAK,SAAU;AACnB,SAAK,OAAO,KAAKA,CAAO;AACxB,UAAMC,IAAM,KAAK,IAAA,GACXC,IAAOD,IAAM,KAAK;AACxB,QAAIC,IAAO,KAAK,KAAK,SAAU;AAC/B,UAAMC,IAAS,KAAK;AAGpB,QAFA,KAAK,SAAS,CAAA,GACd,KAAK,QAAQF,GACTE,EAAO,SAAS,KAAK,KAAK,UAAW;AACzC,UAAMC,IAAUC,EAAgBF,GAAQD,GAAM,KAAK,KAAK,OAAO;AAC/D,IAAII,EAAeF,GAAS,KAAK,KAAK,iBAAiB,KACvD,KAAK,SAASA,CAAO;AAAA,EACvB;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,SAAS,CAAA,GACd,KAAK,QAAQ,KAAK,IAAA;AAAA,EACpB;AAAA;AAAA,EAGA,OAAOG,GAA4B;AACjC,UAAMC,IAAO,MAAM,KAAK,KAAKD,EAAO,OAAO;AAC3C,WAAAA,EAAO,IAAIC,GAAM,QAAWC,EAAgB,OAAO,GAC5C,MAAMF,EAAO,OAAOC,CAAI;AAAA,EACjC;AACF;"}

package/dist/diagnostics/bootWatch.js

@@ -0,0 +1,21 @@
+function c(o, i, n = () => performance.now()) {
+  const a = n(), t = [{ name: "init", atMs: 0 }];
+  let s = !1;
+  const r = setTimeout(() => {
+    if (s) return;
+    const e = t[t.length - 1].name;
+    i({ step: e, steps: t.slice(), detail: `stuck: ${e}` });
+  }, o);
+  return {
+    step(e) {
+      s || t.push({ name: e, atMs: Math.round(n() - a) });
+    },
+    done() {
+      s = !0, clearTimeout(r);
+    }
+  };
+}
+export {
+  c as bootWatch
+};
+//# sourceMappingURL=bootWatch.js.map

package/dist/diagnostics/bootWatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootWatch.js","sources":["../../src/diagnostics/bootWatch.ts"],"sourcesContent":["/** What `bootWatch` reports when a start hangs. */\nexport interface BootStall {\n  /** The step the start stood on. */\n  step: string;\n  /** Every step reached, in order, with the ms since the watch began when each was reached. */\n  steps: { name: string; atMs: number }[];\n  /** `stuck: <step>`, a line short enough for a player's screenshot. */\n  detail: string;\n}\n\nexport interface BootWatch {\n  /** Moves the watch on to a named step. */\n  step(name: string): void;\n  /** The start finished: the watch stops. */\n  done(): void;\n}\n\n/**\n * Says when a start has not finished `ms` after it began, naming the step it stood on. A world that never got built\n * otherwise leaves the player looking at a loading line forever while the rest of the page goes on under it; named\n * steps turn \"it hangs\" into \"it hangs loading textures\".\n */\nexport function bootWatch(ms: number, onStuck: (stall: BootStall) => void, now: () => number = () => performance.now()): BootWatch {\n  const began = now();\n  const steps = [{ name: 'init', atMs: 0 }];\n  let finished = false;\n  const timer = setTimeout(() => {\n    if (finished) return;\n    const step = steps[steps.length - 1]!.name;\n    onStuck({ step, steps: steps.slice(), detail: `stuck: ${step}` });\n  }, ms);\n  return {\n    step(name: string) {\n      if (!finished) steps.push({ name, atMs: Math.round(now() - began) });\n    },\n    done() {\n      finished = true;\n      clearTimeout(timer);\n    },\n  };\n}\n"],"names":["bootWatch","ms","onStuck","now","began","steps","finished","timer","step","name"],"mappings":"AAsBO,SAASA,EAAUC,GAAYC,GAAqCC,IAAoB,MAAM,YAAY,OAAkB;AACjI,QAAMC,IAAQD,EAAA,GACRE,IAAQ,CAAC,EAAE,MAAM,QAAQ,MAAM,GAAG;AACxC,MAAIC,IAAW;AACf,QAAMC,IAAQ,WAAW,MAAM;AAC7B,QAAID,EAAU;AACd,UAAME,IAAOH,EAAMA,EAAM,SAAS,CAAC,EAAG;AACtC,IAAAH,EAAQ,EAAE,MAAAM,GAAM,OAAOH,EAAM,SAAS,QAAQ,UAAUG,CAAI,GAAA,CAAI;AAAA,EAClE,GAAGP,CAAE;AACL,SAAO;AAAA,IACL,KAAKQ,GAAc;AACjB,MAAKH,KAAUD,EAAM,KAAK,EAAE,MAAAI,GAAM,MAAM,KAAK,MAAMN,MAAQC,CAAK,GAAG;AAAA,IACrE;AAAA,IACA,OAAO;AACL,MAAAE,IAAW,IACX,aAAaC,CAAK;AAAA,IACpB;AAAA,EAAA;AAEJ;"}

package/dist/diagnostics/captureErrors.js

@@ -0,0 +1,27 @@
+import { Stage as r } from "../core/Stage.js";
+import { ErrorDeduper as l, trimStack as v } from "./ErrorDeduper.js";
+function k(m, t = {}) {
+  const g = t.deduper ?? new l(t.max ?? 10), a = (e, n, s) => {
+    const u = g.admit(e);
+    u !== null && m({ message: u, stack: v(n), source: s });
+  }, i = (e) => a(e.message || String(e.error), e.error?.stack, "uncaught"), c = (e) => {
+    const n = e.reason;
+    a(n?.message ?? String(e.reason), n?.stack, "rejection");
+  }, f = (e, n) => {
+    const s = n;
+    a(`${e}: ${s?.message ?? String(n)}`, s?.stack, "frame");
+  }, o = typeof window < "u" ? window : void 0;
+  o?.addEventListener("error", i), o?.addEventListener("unhandledrejection", c);
+  const d = r.onCaught;
+  t.frames !== !1 && (r.onCaught = (e, n) => {
+    d?.(e, n), f(e, n);
+  });
+  const h = r.onCaught;
+  return () => {
+    o?.removeEventListener("error", i), o?.removeEventListener("unhandledrejection", c), t.frames !== !1 && r.onCaught === h && (r.onCaught = d);
+  };
+}
+export {
+  k as captureErrors
+};
+//# sourceMappingURL=captureErrors.js.map

package/dist/diagnostics/captureErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"captureErrors.js","sources":["../../src/diagnostics/captureErrors.ts"],"sourcesContent":["import { Stage } from '../core/Stage';\nimport { ErrorDeduper, trimStack } from './ErrorDeduper';\n\n/** One error, as handed to `captureErrors`' callback. */\nexport interface CapturedError {\n  message: string;\n  /** The first lines of its stack, or ''. */\n  stack: string;\n  /** `uncaught`, `rejection`, or `frame` for one a `Stage` step caught so the frame could go on. */\n  source: 'uncaught' | 'rejection' | 'frame';\n}\n\nexport interface CaptureErrorsOptions {\n  /** Distinct errors reported in all (default 10). */\n  max?: number;\n  /** Also report what a `Stage` frame caught (`Stage.onCaught`; default true): there a fault shows only as a stuck view. */\n  frames?: boolean;\n  /** Shared with the game's own reports (`admit` before sending), so one error is not told twice. */\n  deduper?: ErrorDeduper;\n}\n\n/**\n * Hands every error nothing else caught — `error` and `unhandledrejection` on the window, and what a frame caught —\n * to `onError`, each distinct one once. The engine sends nothing itself; reporting it is the game's. Returns the\n * uninstall, which puts back whatever held `Stage.onCaught` before.\n */\nexport function captureErrors(onError: (e: CapturedError) => void, options: CaptureErrorsOptions = {}): () => void {\n  const dedupe = options.deduper ?? new ErrorDeduper(options.max ?? 10);\n  const report = (message: string, stack: string | undefined, source: CapturedError['source']) => {\n    const key = dedupe.admit(message);\n    if (key !== null) onError({ message: key, stack: trimStack(stack), source });\n  };\n  const onWindowError = (e: ErrorEvent) => report(e.message || String(e.error), (e.error as { stack?: string } | undefined)?.stack, 'uncaught');\n  const onRejection = (e: PromiseRejectionEvent) => {\n    const r = e.reason as { message?: string; stack?: string } | undefined;\n    report(r?.message ?? String(e.reason), r?.stack, 'rejection');\n  };\n  const onCaught = (where: string, err: unknown) => {\n    const e = err as { message?: string; stack?: string } | undefined;\n    report(`${where}: ${e?.message ?? String(err)}`, e?.stack, 'frame');\n  };\n  const win = typeof window !== 'undefined' ? window : undefined;\n  win?.addEventListener('error', onWindowError);\n  win?.addEventListener('unhandledrejection', onRejection);\n  const previous = Stage.onCaught;\n  if (options.frames !== false) {\n    Stage.onCaught = (where, err) => {\n      previous?.(where, err);\n      onCaught(where, err);\n    };\n  }\n  const installed = Stage.onCaught;\n  return () => {\n    win?.removeEventListener('error', onWindowError);\n    win?.removeEventListener('unhandledrejection', onRejection);\n    if (options.frames !== false && Stage.onCaught === installed) Stage.onCaught = previous;\n  };\n}\n"],"names":["captureErrors","onError","options","dedupe","ErrorDeduper","report","message","stack","source","key","trimStack","onWindowError","onRejection","r","onCaught","where","err","e","win","previous","Stage","installed"],"mappings":";;AA0BO,SAASA,EAAcC,GAAqCC,IAAgC,IAAgB;AACjH,QAAMC,IAASD,EAAQ,WAAW,IAAIE,EAAaF,EAAQ,OAAO,EAAE,GAC9DG,IAAS,CAACC,GAAiBC,GAA2BC,MAAoC;AAC9F,UAAMC,IAAMN,EAAO,MAAMG,CAAO;AAChC,IAAIG,MAAQ,QAAMR,EAAQ,EAAE,SAASQ,GAAK,OAAOC,EAAUH,CAAK,GAAG,QAAAC,EAAA,CAAQ;AAAA,EAC7E,GACMG,IAAgB,CAAC,MAAkBN,EAAO,EAAE,WAAW,OAAO,EAAE,KAAK,GAAI,EAAE,OAA0C,OAAO,UAAU,GACtIO,IAAc,CAAC,MAA6B;AAChD,UAAMC,IAAI,EAAE;AACZ,IAAAR,EAAOQ,GAAG,WAAW,OAAO,EAAE,MAAM,GAAGA,GAAG,OAAO,WAAW;AAAA,EAC9D,GACMC,IAAW,CAACC,GAAeC,MAAiB;AAChD,UAAMC,IAAID;AACV,IAAAX,EAAO,GAAGU,CAAK,KAAKE,GAAG,WAAW,OAAOD,CAAG,CAAC,IAAIC,GAAG,OAAO,OAAO;AAAA,EACpE,GACMC,IAAM,OAAO,SAAW,MAAc,SAAS;AACrD,EAAAA,GAAK,iBAAiB,SAASP,CAAa,GAC5CO,GAAK,iBAAiB,sBAAsBN,CAAW;AACvD,QAAMO,IAAWC,EAAM;AACvB,EAAIlB,EAAQ,WAAW,OACrBkB,EAAM,WAAW,CAACL,GAAOC,MAAQ;AAC/B,IAAAG,IAAWJ,GAAOC,CAAG,GACrBF,EAASC,GAAOC,CAAG;AAAA,EACrB;AAEF,QAAMK,IAAYD,EAAM;AACxB,SAAO,MAAM;AACX,IAAAF,GAAK,oBAAoB,SAASP,CAAa,GAC/CO,GAAK,oBAAoB,sBAAsBN,CAAW,GACtDV,EAAQ,WAAW,MAASkB,EAAM,aAAaC,QAAiB,WAAWF;AAAA,EACjF;AACF;"}

package/dist/diagnostics/contextLoss.js

@@ -0,0 +1,25 @@
+function u(e, s, t = !1, d = {}) {
+  const { maxLosses: c = 3, windowMs: r = 12e4 } = d, o = e.filter((l) => s - l < r), n = t ? o : o.concat(s);
+  return { losses: n, giveUp: n.length > c, delayMs: f(n.length) };
+}
+function f(e) {
+  return e <= 1 ? 250 : e === 2 ? 2e3 : 5e3;
+}
+function w(e, s, t = {}) {
+  const d = t.now ?? (() => performance.now()), c = t.hidden ?? (() => typeof document < "u" && document.hidden);
+  let r = [];
+  const o = (l) => {
+    l.preventDefault();
+    const i = u(r, d(), c(), t);
+    r = i.losses, s(i);
+  }, n = () => t.onRestored?.();
+  return e.addEventListener("webglcontextlost", o), e.addEventListener("webglcontextrestored", n), () => {
+    e.removeEventListener("webglcontextlost", o), e.removeEventListener("webglcontextrestored", n);
+  };
+}
+export {
+  u as noteContextLoss,
+  f as rebuildDelayMs,
+  w as watchContextLoss
+};
+//# sourceMappingURL=contextLoss.js.map

package/dist/diagnostics/contextLoss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextLoss.js","sources":["../../src/diagnostics/contextLoss.ts"],"sourcesContent":["/*\n * A WebGL context can be taken away at any time: a phone's GPU resetting, a driver crash, an Android WebView taking\n * the GPU back from an app in the background. Pixi does not rebuild a lost world by itself, so the game must — and a\n * GPU that keeps dropping it will not be saved by another try, so after a few losses in a short while it should stop\n * and say so instead of rebuilding forever.\n */\n\nexport interface ContextLossPolicy {\n  /** Losses tolerated inside `windowMs` before giving up (default 3). */\n  maxLosses?: number;\n  /** How far back losses are counted, ms (default two minutes). */\n  windowMs?: number;\n}\n\nexport interface ContextLossVerdict {\n  /** The losses still inside the window, this one included (unless the page was hidden). */\n  losses: number[];\n  /** Stop rebuilding: the GPU keeps failing. */\n  giveUp: boolean;\n  /** How long to wait before rebuilding (`rebuildDelayMs`). */\n  delayMs: number;\n}\n\n/**\n * One more context loss at `now`, given the earlier ones. A loss while the page is `hidden` is the system taking the\n * GPU back, not the GPU failing, so it is not counted against it.\n */\nexport function noteContextLoss(earlier: readonly number[], now: number, hidden = false, policy: ContextLossPolicy = {}): ContextLossVerdict {\n  const { maxLosses = 3, windowMs = 120_000 } = policy;\n  const kept = earlier.filter((t) => now - t < windowMs);\n  const losses = hidden ? kept : kept.concat(now);\n  return { losses, giveUp: losses.length > maxLosses, delayMs: rebuildDelayMs(losses.length) };\n}\n\n/**\n * How long to wait before rebuilding after a loss, with `losses` counted in the window: a GPU that has just reset is\n * given longer each time it drops the context again (a rebuild at once was dropped at once on a phone).\n */\nexport function rebuildDelayMs(losses: number): number {\n  return losses <= 1 ? 250 : losses === 2 ? 2_000 : 5_000;\n}\n\n/**\n * Calls `onLost` with a verdict each time `canvas` (the renderer's) loses its WebGL context; the game tears its world\n * down and rebuilds it after `delayMs`, or shows an error when `giveUp`. The event's default is prevented, which is\n * what lets the browser restore the context at all. Returns the uninstall.\n */\nexport function watchContextLoss(\n  canvas: EventTarget,\n  onLost: (verdict: ContextLossVerdict) => void,\n  options: ContextLossPolicy & { onRestored?: () => void; now?: () => number; hidden?: () => boolean } = {},\n): () => void {\n  const now = options.now ?? (() => performance.now());\n  const hidden = options.hidden ?? (() => typeof document !== 'undefined' && document.hidden);\n  let losses: number[] = [];\n  const lost = (e: Event) => {\n    e.preventDefault();\n    const verdict = noteContextLoss(losses, now(), hidden(), options);\n    losses = verdict.losses;\n    onLost(verdict);\n  };\n  const restored = () => options.onRestored?.();\n  canvas.addEventListener('webglcontextlost', lost);\n  canvas.addEventListener('webglcontextrestored', restored);\n  return () => {\n    canvas.removeEventListener('webglcontextlost', lost);\n    canvas.removeEventListener('webglcontextrestored', restored);\n  };\n}\n"],"names":["noteContextLoss","earlier","now","hidden","policy","maxLosses","windowMs","kept","t","losses","rebuildDelayMs","watchContextLoss","canvas","onLost","options","lost","e","verdict","restored"],"mappings":"AA2BO,SAASA,EAAgBC,GAA4BC,GAAaC,IAAS,IAAOC,IAA4B,IAAwB;AAC3I,QAAM,EAAE,WAAAC,IAAY,GAAG,UAAAC,IAAW,SAAYF,GACxCG,IAAON,EAAQ,OAAO,CAACO,MAAMN,IAAMM,IAAIF,CAAQ,GAC/CG,IAASN,IAASI,IAAOA,EAAK,OAAOL,CAAG;AAC9C,SAAO,EAAE,QAAAO,GAAQ,QAAQA,EAAO,SAASJ,GAAW,SAASK,EAAeD,EAAO,MAAM,EAAA;AAC3F;AAMO,SAASC,EAAeD,GAAwB;AACrD,SAAOA,KAAU,IAAI,MAAMA,MAAW,IAAI,MAAQ;AACpD;AAOO,SAASE,EACdC,GACAC,GACAC,IAAuG,CAAA,GAC3F;AACZ,QAAMZ,IAAMY,EAAQ,QAAQ,MAAM,YAAY,IAAA,IACxCX,IAASW,EAAQ,WAAW,MAAM,OAAO,WAAa,OAAe,SAAS;AACpF,MAAIL,IAAmB,CAAA;AACvB,QAAMM,IAAO,CAACC,MAAa;AACzB,IAAAA,EAAE,eAAA;AACF,UAAMC,IAAUjB,EAAgBS,GAAQP,KAAOC,EAAA,GAAUW,CAAO;AAChE,IAAAL,IAASQ,EAAQ,QACjBJ,EAAOI,CAAO;AAAA,EAChB,GACMC,IAAW,MAAMJ,EAAQ,aAAA;AAC/B,SAAAF,EAAO,iBAAiB,oBAAoBG,CAAI,GAChDH,EAAO,iBAAiB,wBAAwBM,CAAQ,GACjD,MAAM;AACX,IAAAN,EAAO,oBAAoB,oBAAoBG,CAAI,GACnDH,EAAO,oBAAoB,wBAAwBM,CAAQ;AAAA,EAC7D;AACF;"}

package/dist/diagnostics/frameStats.js

@@ -0,0 +1,31 @@
+function h(t, n) {
+  return t.length === 0 ? 0 : t[Math.min(t.length - 1, Math.max(0, Math.floor(t.length * n)))];
+}
+function f(t, n) {
+  let o = 0;
+  for (const e of t) e > n && o++;
+  return o;
+}
+const r = (t) => Math.round(t * 10) / 10;
+function a(t, n, o = 50) {
+  const e = [...t].sort((i, u) => i - u);
+  return {
+    frames: t.length,
+    fps: n > 0 ? r(t.length * 1e3 / n) : 0,
+    fpsLow: r(1e3 / Math.max(1, h(e, 0.99))),
+    frameP95: r(h(e, 0.95)),
+    frameMedian: r(h(e, 0.5)),
+    worstMs: r(e[e.length - 1] ?? 0),
+    hitches: f(t, o)
+  };
+}
+function c(t, n = 500) {
+  return t.frameMedian > n;
+}
+export {
+  f as countHitches,
+  c as looksThrottled,
+  h as percentile,
+  a as summarizeFrames
+};
+//# sourceMappingURL=frameStats.js.map

package/dist/diagnostics/frameStats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameStats.js","sources":["../../src/diagnostics/frameStats.ts"],"sourcesContent":["/** A summary of the frames of one sampling window. */\nexport interface FrameSummary {\n  /** Frames rendered. */\n  frames: number;\n  /** Frames a second over the window. */\n  fps: number;\n  /** The \"1% low\": the frame rate of the slowest hundredth of frames, which is what stutter feels like. */\n  fpsLow: number;\n  /** The 95th-percentile frame time, ms. */\n  frameP95: number;\n  /** The median frame time, ms. */\n  frameMedian: number;\n  /** The longest frame, ms. */\n  worstMs: number;\n  /** Frames longer than the hitch threshold: the ones a player feels. */\n  hitches: number;\n}\n\n/** The value at fraction `p` (0..1) of an ascending list, by nearest rank; 0 for an empty list. */\nexport function percentile(sorted: readonly number[], p: number): number {\n  if (sorted.length === 0) return 0;\n  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.floor(sorted.length * p)))]!;\n}\n\n/** Frames longer than `thresholdMs`. */\nexport function countHitches(frameMs: readonly number[], thresholdMs: number): number {\n  let n = 0;\n  for (const d of frameMs) if (d > thresholdMs) n++;\n  return n;\n}\n\nconst round1 = (n: number) => Math.round(n * 10) / 10;\n\n/** The summary of frame times (ms) rendered over `spanMs`; a frame over `hitchMs` (default 50) is a hitch. */\nexport function summarizeFrames(frameMs: readonly number[], spanMs: number, hitchMs = 50): FrameSummary {\n  const sorted = [...frameMs].sort((a, b) => a - b);\n  return {\n    frames: frameMs.length,\n    fps: spanMs > 0 ? round1((frameMs.length * 1000) / spanMs) : 0,\n    fpsLow: round1(1000 / Math.max(1, percentile(sorted, 0.99))),\n    frameP95: round1(percentile(sorted, 0.95)),\n    frameMedian: round1(percentile(sorted, 0.5)),\n    worstMs: round1(sorted[sorted.length - 1] ?? 0),\n    hitches: countHitches(frameMs, hitchMs),\n  };\n}\n\n/**\n * A window the browser throttled: one covered by another window is not `hidden`, but runs at about a frame a second,\n * and a second copy of a game parked behind the first read as its heaviest scene. Nothing really played runs with\n * its median frame half a second long.\n */\nexport function looksThrottled(summary: FrameSummary, medianLimitMs = 500): boolean {\n  return summary.frameMedian > medianLimitMs;\n}\n"],"names":["percentile","sorted","p","countHitches","frameMs","thresholdMs","n","d","round1","summarizeFrames","spanMs","hitchMs","a","b","looksThrottled","summary","medianLimitMs"],"mappings":"AAmBO,SAASA,EAAWC,GAA2BC,GAAmB;AACvE,SAAID,EAAO,WAAW,IAAU,IACzBA,EAAO,KAAK,IAAIA,EAAO,SAAS,GAAG,KAAK,IAAI,GAAG,KAAK,MAAMA,EAAO,SAASC,CAAC,CAAC,CAAC,CAAC;AACvF;AAGO,SAASC,EAAaC,GAA4BC,GAA6B;AACpF,MAAIC,IAAI;AACR,aAAWC,KAAKH,EAAS,CAAIG,IAAIF,KAAaC;AAC9C,SAAOA;AACT;AAEA,MAAME,IAAS,CAACF,MAAc,KAAK,MAAMA,IAAI,EAAE,IAAI;AAG5C,SAASG,EAAgBL,GAA4BM,GAAgBC,IAAU,IAAkB;AACtG,QAAMV,IAAS,CAAC,GAAGG,CAAO,EAAE,KAAK,CAACQ,GAAGC,MAAMD,IAAIC,CAAC;AAChD,SAAO;AAAA,IACL,QAAQT,EAAQ;AAAA,IAChB,KAAKM,IAAS,IAAIF,EAAQJ,EAAQ,SAAS,MAAQM,CAAM,IAAI;AAAA,IAC7D,QAAQF,EAAO,MAAO,KAAK,IAAI,GAAGR,EAAWC,GAAQ,IAAI,CAAC,CAAC;AAAA,IAC3D,UAAUO,EAAOR,EAAWC,GAAQ,IAAI,CAAC;AAAA,IACzC,aAAaO,EAAOR,EAAWC,GAAQ,GAAG,CAAC;AAAA,IAC3C,SAASO,EAAOP,EAAOA,EAAO,SAAS,CAAC,KAAK,CAAC;AAAA,IAC9C,SAASE,EAAaC,GAASO,CAAO;AAAA,EAAA;AAE1C;AAOO,SAASG,EAAeC,GAAuBC,IAAgB,KAAc;AAClF,SAAOD,EAAQ,cAAcC;AAC/B;"}

package/dist/diagnostics/gpuInfo.js

@@ -0,0 +1,22 @@
+function u(n) {
+  return n.gl;
+}
+function l(n) {
+  const t = u(n);
+  if (!t) return null;
+  const e = Number(t.getParameter(t.MAX_TEXTURE_SIZE));
+  return Number.isFinite(e) && e > 0 ? e : null;
+}
+function i(n, t = 80) {
+  try {
+    const e = u(n), r = e?.getExtension("WEBGL_debug_renderer_info");
+    return e && r ? String(e.getParameter(r.UNMASKED_RENDERER_WEBGL)).slice(0, t) : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  i as gpuName,
+  l as maxTextureSize
+};
+//# sourceMappingURL=gpuInfo.js.map

package/dist/diagnostics/gpuInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpuInfo.js","sources":["../../src/diagnostics/gpuInfo.ts"],"sourcesContent":["import type { Renderer } from 'pixi.js';\n\nfunction glOf(renderer: Renderer): WebGLRenderingContext | undefined {\n  return (renderer as { gl?: WebGLRenderingContext }).gl;\n}\n\n/**\n * The largest texture side the GPU takes (WebGL's MAX_TEXTURE_SIZE), or null when the renderer is not WebGL. Many\n * phones stop at 4096, so an atlas planned for 8192 must split its pages there (`atlasPageLimit`).\n */\nexport function maxTextureSize(renderer: Renderer): number | null {\n  const gl = glOf(renderer);\n  if (!gl) return null;\n  const n = Number(gl.getParameter(gl.MAX_TEXTURE_SIZE));\n  return Number.isFinite(n) && n > 0 ? n : null;\n}\n\n/** The GPU's own name where the browser gives it (WEBGL_debug_renderer_info), else null; for telling devices apart. */\nexport function gpuName(renderer: Renderer, max = 80): string | null {\n  try {\n    const gl = glOf(renderer);\n    const ext = gl?.getExtension('WEBGL_debug_renderer_info');\n    return gl && ext ? String(gl.getParameter(ext.UNMASKED_RENDERER_WEBGL)).slice(0, max) : null;\n  } catch {\n    return null;\n  }\n}\n"],"names":["glOf","renderer","maxTextureSize","gl","n","gpuName","max","ext"],"mappings":"AAEA,SAASA,EAAKC,GAAuD;AACnE,SAAQA,EAA4C;AACtD;AAMO,SAASC,EAAeD,GAAmC;AAChE,QAAME,IAAKH,EAAKC,CAAQ;AACxB,MAAI,CAACE,EAAI,QAAO;AAChB,QAAMC,IAAI,OAAOD,EAAG,aAAaA,EAAG,gBAAgB,CAAC;AACrD,SAAO,OAAO,SAASC,CAAC,KAAKA,IAAI,IAAIA,IAAI;AAC3C;AAGO,SAASC,EAAQJ,GAAoBK,IAAM,IAAmB;AACnE,MAAI;AACF,UAAMH,IAAKH,EAAKC,CAAQ,GAClBM,IAAMJ,GAAI,aAAa,2BAA2B;AACxD,WAAOA,KAAMI,IAAM,OAAOJ,EAAG,aAAaI,EAAI,uBAAuB,CAAC,EAAE,MAAM,GAAGD,CAAG,IAAI;AAAA,EAC1F,QAAQ;AACN,WAAO;AAAA,EACT;AACF;"}

package/dist/diagnostics/renderGuard.js

@@ -0,0 +1,24 @@
+import { UPDATE_PRIORITY as c } from "pixi.js";
+function f(e, t = 160) {
+  const r = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+  return r.length > t ? `${r.slice(0, t)}…` : r;
+}
+function l(e, t, r = 30) {
+  e.ticker.remove(e.render, e);
+  let n = 0, d = !1;
+  const i = () => {
+    try {
+      e.render(), n = 0;
+    } catch (o) {
+      n++, n === 1 && console.error("[render] frame failed", o), n >= r && !d && (d = !0, t(`render: ${f(o)}`, o));
+    }
+  };
+  return e.ticker.add(i, void 0, c.LOW), () => {
+    e.ticker.remove(i), e.ticker.add(e.render, e, c.LOW);
+  };
+}
+export {
+  f as describeError,
+  l as guardRender
+};
+//# sourceMappingURL=renderGuard.js.map

package/dist/diagnostics/renderGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderGuard.js","sources":["../../src/diagnostics/renderGuard.ts"],"sourcesContent":["import { type Application, UPDATE_PRIORITY } from 'pixi.js';\n\n/** An error as one short line, for a player's screenshot or a report. */\nexport function describeError(err: unknown, max = 160): string {\n  const text = err instanceof Error ? `${err.name}: ${err.message}` : String(err);\n  return text.length > max ? `${text.slice(0, max)}…` : text;\n}\n\n/**\n * Replaces Pixi's render on the ticker with one that survives a throw and reports a renderer that keeps failing.\n * A ticker listener that throws never asks for the next frame, and `Stage`'s per-step guard covers the game's steps,\n * not the renderer's: a render that threw on its first frame froze the canvas in silence while the page went on.\n * A single bad frame is let go; `failures` in a row are reported once. Returns the uninstall, which puts Pixi's own\n * render back.\n */\nexport function guardRender(app: Application, onFail: (detail: string, err: unknown) => void, failures = 30): () => void {\n  app.ticker.remove(app.render, app);\n  let inARow = 0;\n  let told = false;\n  const render = () => {\n    try {\n      app.render();\n      inARow = 0;\n    } catch (err) {\n      inARow++;\n      if (inARow === 1) console.error('[render] frame failed', err);\n      if (inARow >= failures && !told) {\n        told = true;\n        onFail(`render: ${describeError(err)}`, err);\n      }\n    }\n  };\n  app.ticker.add(render, undefined, UPDATE_PRIORITY.LOW);\n  return () => {\n    app.ticker.remove(render);\n    app.ticker.add(app.render, app, UPDATE_PRIORITY.LOW);\n  };\n}\n"],"names":["describeError","err","max","text","guardRender","app","onFail","failures","inARow","told","render","UPDATE_PRIORITY"],"mappings":";AAGO,SAASA,EAAcC,GAAcC,IAAM,KAAa;AAC7D,QAAMC,IAAOF,aAAe,QAAQ,GAAGA,EAAI,IAAI,KAAKA,EAAI,OAAO,KAAK,OAAOA,CAAG;AAC9E,SAAOE,EAAK,SAASD,IAAM,GAAGC,EAAK,MAAM,GAAGD,CAAG,CAAC,MAAMC;AACxD;AASO,SAASC,EAAYC,GAAkBC,GAAgDC,IAAW,IAAgB;AACvH,EAAAF,EAAI,OAAO,OAAOA,EAAI,QAAQA,CAAG;AACjC,MAAIG,IAAS,GACTC,IAAO;AACX,QAAMC,IAAS,MAAM;AACnB,QAAI;AACF,MAAAL,EAAI,OAAA,GACJG,IAAS;AAAA,IACX,SAASP,GAAK;AACZ,MAAAO,KACIA,MAAW,KAAG,QAAQ,MAAM,yBAAyBP,CAAG,GACxDO,KAAUD,KAAY,CAACE,MACzBA,IAAO,IACPH,EAAO,WAAWN,EAAcC,CAAG,CAAC,IAAIA,CAAG;AAAA,IAE/C;AAAA,EACF;AACA,SAAAI,EAAI,OAAO,IAAIK,GAAQ,QAAWC,EAAgB,GAAG,GAC9C,MAAM;AACX,IAAAN,EAAI,OAAO,OAAOK,CAAM,GACxBL,EAAI,OAAO,IAAIA,EAAI,QAAQA,GAAKM,EAAgB,GAAG;AAAA,EACrD;AACF;"}