1681-engine 0.5.8 → 0.5.10

package/dist/debug/DrawCallCounter.js

@@ -1,5 +1,5 @@
-const c = ["drawElements", "drawArrays", "drawElementsInstanced", "drawArraysInstanced"];
-class i {
+const u = ["drawElements", "drawArrays", "drawElementsInstanced", "drawArraysInstanced", "drawRangeElements"];
+class f {
   constructor(r) {
     this.renderer = r;
   }
@@ -9,18 +9,22 @@ class i {
   restore = null;
   /** Whether this renderer can be counted (WebGL). */
   get supported() {
-    return o(this.renderer) !== null;
+    return c(this.renderer) !== null;
   }
   install() {
-    const r = o(this.renderer);
+    const r = c(this.renderer);
     if (!r || this.restore) return;
-    const n = r, l = [];
-    for (const t of c) {
+    const n = r, o = [];
+    let a = !0;
+    for (const t of u) {
       const e = n[t];
-      typeof e == "function" && (l.push([t, e]), n[t] = (...a) => (this.calls++, e.apply(r, a)));
+      if (typeof e != "function") continue;
+      const s = (...i) => (a && this.calls++, e.apply(r, i));
+      o.push([t, e, s]), n[t] = s;
     }
     this.restore = () => {
-      for (const [t, e] of l) n[t] = e;
+      a = !1;
+      for (const [t, e, s] of o) n[t] === s && (n[t] = e);
     };
   }
   uninstall() {
@@ -32,10 +36,9 @@ class i {
     return this.calls = 0, r;
   }
 }
-function o(s) {
-  return s.gl ?? null;
+function c(l) {
+  return l.gl ?? null;
 }
 export {
-  i as DrawCallCounter
+  f as DrawCallCounter
 };
-//# sourceMappingURL=DrawCallCounter.js.map

package/dist/debug/ErrorLog.js

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

package/dist/debug/FrameStats.js

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

package/dist/debug/inspectWorld.js

@@ -26,4 +26,3 @@ function f(t, r, s) {
 export {
   p as inspectWorld
 };
-//# sourceMappingURL=inspectWorld.js.map

package/dist/diagnostics/ErrorDeduper.js

@@ -24,4 +24,3 @@ export {
   n as ErrorDeduper,
   i as trimStack
 };
-//# sourceMappingURL=ErrorDeduper.js.map

package/dist/diagnostics/FrameSampler.js

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

package/dist/diagnostics/bootWatch.js

@@ -18,4 +18,3 @@ function c(o, i, n = () => performance.now()) {
 export {
   c as bootWatch
 };
-//# sourceMappingURL=bootWatch.js.map

package/dist/diagnostics/captureErrors.js

@@ -24,4 +24,3 @@ function k(m, t = {}) {
 export {
   k as captureErrors
 };
-//# sourceMappingURL=captureErrors.js.map

package/dist/diagnostics/contextLoss.js

@@ -22,4 +22,3 @@ export {
   f as rebuildDelayMs,
   w as watchContextLoss
 };
-//# sourceMappingURL=contextLoss.js.map

package/dist/diagnostics/frameStats.js

@@ -28,4 +28,3 @@ export {
   h as percentile,
   a as summarizeFrames
 };
-//# sourceMappingURL=frameStats.js.map

package/dist/diagnostics/gpuInfo.js

@@ -19,4 +19,3 @@ export {
   i as gpuName,
   l as maxTextureSize
 };
-//# sourceMappingURL=gpuInfo.js.map

package/dist/diagnostics/renderGuard.js

@@ -21,4 +21,3 @@ export {
   f as describeError,
   l as guardRender
 };
-//# sourceMappingURL=renderGuard.js.map

package/dist/ecs/SparseSet.js

@@ -52,4 +52,3 @@ class n {
 export {
   n as SparseSet
 };
-//# sourceMappingURL=SparseSet.js.map

package/dist/ecs/World.js

@@ -304,4 +304,3 @@ export {
   h as entityIndex,
   b as system
 };
-//# sourceMappingURL=World.js.map

package/dist/ecs/fields.js

@@ -23,4 +23,3 @@ export {
   f as growColumns,
   u as isFields
 };
-//# sourceMappingURL=fields.js.map

package/dist/electron/lockdown.js

@@ -0,0 +1,31 @@
+import { isAllowedNavigation as a, isDevToolsKey as d, debuggerRequested as f, isAllowedExternal as u } from "./lockdownRules.js";
+function g(r, n) {
+  const i = n.log ?? ((...e) => console.log(...e)), t = r.webContents, s = (e, o) => {
+    u(e, n.external) ? n.shell.openExternal(e).catch((c) => i("could not open", e, c)) : i(`refused ${o}:`, e);
+  };
+  t.setWindowOpenHandler(({ url: e }) => (s(e, "external link"), { action: "deny" })), t.on("will-navigate", (e, o) => {
+    a(o, n.devServerUrl) || (e.preventDefault(), s(o, "navigation"));
+  }), t.on("will-redirect", (e, o) => {
+    a(o, n.devServerUrl) || e.preventDefault();
+  });
+  const l = n.devToolsKey === void 0 ? "F12" : n.devToolsKey;
+  t.on("before-input-event", (e, o) => {
+    if (n.packaged) {
+      d(o) && e.preventDefault();
+      return;
+    }
+    l && o.type === "keyDown" && o.key === l && (t.toggleDevTools(), e.preventDefault());
+  });
+}
+function w(r, n = []) {
+  const i = new Set(n);
+  r.setPermissionRequestHandler((t, s, l) => l(i.has(s))), r.setPermissionCheckHandler((t, s) => i.has(s));
+}
+function p(r, n = process.argv, i = (t) => process.exit(t)) {
+  return !r.isPackaged || !f(n, (t) => r.commandLine.hasSwitch(t)) ? !1 : (console.error("[main] refusing to run with a debugger attached"), i(1), !0);
+}
+export {
+  w as denyPermissions,
+  g as lockDownWindow,
+  p as refuseDebugLaunch
+};

package/dist/electron/lockdownRules.js

@@ -0,0 +1,42 @@
+function i(e) {
+  try {
+    return new URL(e);
+  } catch {
+    return null;
+  }
+}
+function g(e, r) {
+  const t = i(e);
+  if (!t || t.protocol !== "https:" || t.username || t.password) return !1;
+  const o = t.hostname.toLowerCase(), s = (r.paths ?? []).filter((n) => n.host.toLowerCase() === o);
+  return s.length ? s.some((n) => t.pathname.toLowerCase().startsWith(n.prefix.toLowerCase())) : r.hosts.some((n) => {
+    const a = n.toLowerCase();
+    return o === a || o.endsWith(`.${a}`);
+  });
+}
+function f(e, r) {
+  const t = i(e);
+  if (!t) return !1;
+  if (r) {
+    const o = i(r);
+    return !!o && t.origin === o.origin;
+  }
+  return t.protocol === "file:";
+}
+function l(e) {
+  if (e.type !== "keyDown") return !1;
+  if (e.key === "F12") return !0;
+  const r = e.key.toLowerCase();
+  return (e.control || e.meta) && (e.shift || e.alt) && (r === "i" || r === "j" || r === "c");
+}
+const c = ["--inspect", "--remote-debugging-port", "--remote-debugging-pipe", "--remote-debugging-address"], u = ["remote-debugging-port", "remote-debugging-pipe", "inspect", "inspect-brk"];
+function d(e, r = () => !1) {
+  return e.some((o) => c.some((s) => o === s || o.startsWith(`${s}=`) || o.startsWith(`${s}-`))) || u.some((o) => r(o));
+}
+export {
+  c as DEBUG_SWITCHES,
+  d as debuggerRequested,
+  g as isAllowedExternal,
+  f as isAllowedNavigation,
+  l as isDevToolsKey
+};

package/dist/electron/sessionStore.js

@@ -0,0 +1,48 @@
+import { promises as r } from "node:fs";
+import { join as n } from "node:path";
+class l {
+  constructor(t) {
+    this.o = t, this.file = n(t.dir, t.fileName ?? "session.bin"), this.maxLength = t.maxLength ?? 4096, this.platform = t.platform ?? process.platform;
+  }
+  o;
+  file;
+  maxLength;
+  platform;
+  /** Whether the OS can encrypt for real here. */
+  canEncrypt() {
+    const t = this.o.safeStorage;
+    return t.isEncryptionAvailable() ? this.platform !== "linux" || t.getSelectedStorageBackend?.() !== "basic_text" : !1;
+  }
+  /** The saved value, or null when there is none, it cannot be decrypted (another OS user, a reinstall) or nothing may be. */
+  async get() {
+    if (!this.canEncrypt()) return null;
+    try {
+      return this.o.safeStorage.decryptString(await r.readFile(this.file));
+    } catch {
+      return null;
+    }
+  }
+  /** Saves `value`; false when it is not a string, too long, or the OS cannot encrypt it. */
+  async set(t) {
+    if (typeof t != "string" || t.length > this.maxLength || !this.canEncrypt()) return !1;
+    const e = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await r.mkdir(this.o.dir, { recursive: !0 }), await r.writeFile(e, this.o.safeStorage.encryptString(t)), await r.rename(e, this.file);
+    } catch (a) {
+      throw await r.rm(e, { force: !0 }), a;
+    }
+    return !0;
+  }
+  async clear() {
+    await r.rm(this.file, { force: !0 });
+  }
+}
+function h(s, t, e = "session") {
+  return s.handle(`${e}:get`, () => t.get()), s.handle(`${e}:set`, (a, i) => t.set(i)), s.handle(`${e}:clear`, () => t.clear()), () => {
+    for (const a of ["get", "set", "clear"]) s.removeHandler?.(`${e}:${a}`);
+  };
+}
+export {
+  l as SessionStore,
+  h as registerSessionStore
+};

package/dist/electron/shellId.js

@@ -0,0 +1,18 @@
+import { createHash as a } from "node:crypto";
+import { readdirSync as f, readFileSync as d } from "node:fs";
+import { join as i } from "node:path";
+function p(n, r) {
+  const o = typeof r == "string" ? { dirs: [r] } : r, s = o.match ?? ((t) => t.endsWith(".cjs")), e = a("sha256");
+  e.update(`electron ${n}
+`);
+  for (const t of o.dirs)
+    for (const c of f(t).filter(s).sort())
+      e.update(`${c}
+`), e.update(d(i(t, c)));
+  for (const t of o.extra ?? []) e.update(`extra ${t}
+`);
+  return e.digest("hex").slice(0, o.length ?? 16);
+}
+export {
+  p as shellId
+};

package/dist/electron/webFiles.js

@@ -0,0 +1,36 @@
+import { createHash as s } from "node:crypto";
+import { readFile as c, mkdir as l, writeFile as u, readdir as f } from "node:fs/promises";
+import { join as r, dirname as h } from "node:path";
+const m = (t) => s("sha256").update(t).digest("hex");
+async function n(t, e = "") {
+  const i = [];
+  for (const a of await f(r(t, e), { withFileTypes: !0 })) {
+    const o = e ? `${e}/${a.name}` : a.name;
+    a.isDirectory() ? i.push(...await n(t, o)) : i.push(o);
+  }
+  return i;
+}
+async function d(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const i of await n(t)) e.set(i, m(await c(r(t, ...i.split("/")))));
+  return e;
+}
+async function F(t, e, i) {
+  const a = r(t, ...e.split("/"));
+  await l(h(a), { recursive: !0 }), await u(a, i);
+}
+async function T(t, e, i) {
+  const a = new AbortController(), o = setTimeout(() => a.abort(), i);
+  try {
+    return await t(e, { signal: a.signal, cache: "no-store" });
+  } finally {
+    clearTimeout(o);
+  }
+}
+export {
+  T as fetchWithTimeout,
+  d as hashWeb,
+  n as listFiles,
+  F as putFile,
+  m as sha256
+};

package/dist/electron/webPatcher.js

@@ -0,0 +1,147 @@
+import { existsSync as b } from "node:fs";
+import { rm as d, mkdir as M, readFile as V, rename as T, readdir as x } from "node:fs/promises";
+import { join as s } from "node:path";
+import { isNewer as y, validManifest as $, fileUrl as U } from "../updates/manifest.js";
+import { planWeb as D } from "../updates/webPlan.js";
+import { fetchWithTimeout as u, hashWeb as E, putFile as g, sha256 as P } from "./webFiles.js";
+import { WebPointers as W } from "./webPointers.js";
+class C {
+  constructor(e) {
+    this.options = e, this.o = {
+      root: e.root,
+      builtinDir: e.builtinDir,
+      appVersion: e.appVersion,
+      channelUrl: e.channelUrl,
+      packaged: e.packaged ?? !0,
+      maxTries: e.maxTries ?? 2,
+      keepPrevious: e.keepPrevious ?? !0,
+      entry: e.entry ?? "index.html",
+      parallel: e.parallel ?? 6,
+      fetchTimeoutMs: e.fetchTimeoutMs ?? 15e3,
+      fetch: e.fetch ?? ((t, i) => globalThis.fetch(t, i)),
+      log: e.log ?? ((...t) => console.error(...t))
+    }, this.pointers = new W(e.root);
+  }
+  options;
+  o;
+  pointers;
+  shellValue = null;
+  /** The web this run loads, and its version (the installed build's own when none is patched in). */
+  loaded = null;
+  /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
+  tidying = Promise.resolve();
+  /** This shell's identity. */
+  get shell() {
+    const e = this.options.shell;
+    return this.shellValue ??= typeof e == "string" ? e : e(), this.shellValue;
+  }
+  /** Where the window loads the page from: a patched web when there is a good one, else the built-in copy. */
+  startEntry() {
+    if (!this.o.packaged)
+      return this.loaded = { dir: this.o.builtinDir, version: this.o.appVersion }, s(this.o.builtinDir, this.o.entry);
+    try {
+      const e = this.pointers.read("pending");
+      this.usable(e) && this.promote(e, 0), this.pointers.write("pending", null);
+      const t = this.pointers.read("active");
+      if (this.usable(t) && (t.booted || t.tries < this.o.maxTries))
+        t.booted || this.pointers.write("active", { ...t, tries: t.tries + 1 }), this.loaded = { dir: s(this.o.root, t.version), version: t.version };
+      else {
+        t && this.pointers.write("active", null);
+        const i = this.pointers.read("previous");
+        this.pointers.write("previous", null), this.o.keepPrevious && i?.booted && this.usable(i) && (this.pointers.write("active", i), this.loaded = { dir: s(this.o.root, i.version), version: i.version });
+      }
+    } catch (e) {
+      this.o.log("[web] could not read the patched web, using the built-in one", e);
+    }
+    return this.loaded ??= { dir: this.o.builtinDir, version: this.o.appVersion }, this.tidying = this.tidy(), s(this.loaded.dir, this.o.entry);
+  }
+  /** The version of the web running now. */
+  webVersion() {
+    return this.loaded?.version ?? this.o.appVersion;
+  }
+  /** The page came up: the web it was loaded from is kept from now on. Call it from the page's own "booted" message. */
+  markBooted() {
+    const e = this.pointers.read("active");
+    e && this.loaded && e.version === this.loaded.version && !e.booted && this.pointers.write("active", { ...e, booted: !0 });
+  }
+  /** The channel's newest build, or null when the store cannot be read. */
+  async latest() {
+    try {
+      const e = await u(this.o.fetch, `${this.o.channelUrl}/latest.json`, this.o.fetchTimeoutMs);
+      if (!e.ok) return null;
+      const t = await e.json();
+      return typeof t?.version == "string" ? t : null;
+    } catch {
+      return null;
+    }
+  }
+  /** Whether `l`'s web can be patched in here rather than installed: newer than the web running, for this shell. */
+  patchable(e) {
+    return !!e.web && e.web.shell === this.shell && y(e.version, this.webVersion());
+  }
+  /**
+   * Builds `l`'s web beside the one running: the files held are copied, the rest downloaded and checked, into
+   * `<version>.part/`, which becomes `<version>/` and the pending web once whole — a crash mid-way never leaves a
+   * folder that looks finished. `onProgress` gets 0–100. Resolves with the version built; throws on any failure.
+   */
+  async prepare(e, t = () => {
+  }) {
+    if (!e.web) throw new Error("no web in this release");
+    const i = await u(this.o.fetch, `${this.o.channelUrl}/${e.web.manifest}`, this.o.fetchTimeoutMs);
+    if (!i.ok) throw new Error(`web manifest ${i.status}`);
+    const o = await i.json();
+    if (!$(o) || o.version !== e.version || o.shell !== this.shell) throw new Error("bad web manifest");
+    const l = s(this.o.root, o.version), p = { version: o.version, shell: o.shell, booted: !1, tries: 0 };
+    if (b(s(l, this.o.entry)) && this.pointers.read("active")?.version !== o.version)
+      return this.pointers.write("pending", p), t(100), o.version;
+    await this.tidying;
+    const f = this.loaded?.dir ?? this.o.builtinDir, h = D(o, await E(f)), n = s(this.o.root, `${o.version}.part`);
+    await d(n, { recursive: !0, force: !0 }), await M(n, { recursive: !0 });
+    for (const r of h.copy) await g(n, r.path, await V(s(f, ...r.from.split("/"))));
+    let v = 0;
+    const w = /* @__PURE__ */ new Map(), m = [...h.download];
+    t(h.bytes ? 0 : 100);
+    const k = async () => {
+      for (let r = m.shift(); r; r = m.shift()) {
+        let a = w.get(r.sha256);
+        if (!a) {
+          const c = await u(this.o.fetch, U(this.o.channelUrl, r.sha256), this.o.fetchTimeoutMs);
+          if (!c.ok) throw new Error(`${r.path}: ${c.status}`);
+          if (a = new Uint8Array(await c.arrayBuffer()), P(a) !== r.sha256) throw new Error(`${r.path}: checksum`);
+          w.set(r.sha256, a), v += r.size, t(Math.min(99, Math.round(v / Math.max(1, h.bytes) * 100)));
+        }
+        await g(n, r.path, a);
+      }
+    };
+    return await Promise.all(Array.from({ length: Math.max(1, this.o.parallel) }, k)), await d(l, { recursive: !0, force: !0 }), await T(n, l), this.pointers.write("pending", p), t(100), o.version;
+  }
+  /**
+   * Puts the pending web in use now and returns the page to load (reload every window from it), or null when there is
+   * none this shell may load. The switch counts as its first start, so a web that never boots is still dropped.
+   */
+  applyPending() {
+    const e = this.pointers.read("pending");
+    return this.usable(e) ? (this.promote(e, 1), this.pointers.write("pending", null), this.loaded = { dir: s(this.o.root, e.version), version: e.version }, s(this.loaded.dir, this.o.entry)) : null;
+  }
+  /** Makes `p` the active web, keeping the one it replaces as the fallback when that one ever booted. */
+  promote(e, t) {
+    const i = this.pointers.read("active");
+    this.o.keepPrevious && i?.booted && i.version !== e.version && this.pointers.write("previous", i), this.pointers.write("active", { ...e, booted: !1, tries: t });
+  }
+  /** A pointer this shell may load: its own shell, newer than the installed build, its folder whole. */
+  usable(e) {
+    return !!e && e.shell === this.shell && y(e.version, this.o.appVersion) && b(s(this.o.root, e.version, this.o.entry));
+  }
+  /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
+  async tidy() {
+    try {
+      const e = ["active", "pending", "previous"], t = new Set([...e.map((i) => this.pointers.read(i)?.version), this.loaded?.version].filter((i) => !!i));
+      for (const i of await x(this.o.root))
+        i.endsWith(".json") || t.has(i) || await d(s(this.o.root, i), { recursive: !0, force: !0 });
+    } catch {
+    }
+  }
+}
+export {
+  C as WebPatcher
+};

package/dist/electron/webPointers.js

@@ -0,0 +1,25 @@
+import { readFileSync as t, mkdirSync as i, writeFileSync as o, rmSync as s } from "node:fs";
+import { join as n } from "node:path";
+class c {
+  constructor(e) {
+    this.root = e;
+  }
+  root;
+  read(e) {
+    try {
+      const r = JSON.parse(t(this.file(e), "utf8"));
+      return typeof r?.version != "string" || typeof r.shell != "string" ? null : { version: r.version, shell: r.shell, booted: r.booted === !0, tries: typeof r.tries == "number" ? r.tries : 0 };
+    } catch {
+      return null;
+    }
+  }
+  write(e, r) {
+    r ? (i(this.root, { recursive: !0 }), o(this.file(e), JSON.stringify(r))) : s(this.file(e), { force: !0 });
+  }
+  file(e) {
+    return n(this.root, `${e}.json`);
+  }
+}
+export {
+  c as WebPointers
+};

package/dist/electron.js

@@ -0,0 +1,19 @@
+import { shellId as r } from "./electron/shellId.js";
+import { WebPatcher as t } from "./electron/webPatcher.js";
+import { SessionStore as l, registerSessionStore as n } from "./electron/sessionStore.js";
+import { DEBUG_SWITCHES as f, debuggerRequested as m, isAllowedExternal as x, isAllowedNavigation as S, isDevToolsKey as a } from "./electron/lockdownRules.js";
+import { denyPermissions as p, lockDownWindow as u, refuseDebugLaunch as w } from "./electron/lockdown.js";
+export {
+  f as DEBUG_SWITCHES,
+  l as SessionStore,
+  t as WebPatcher,
+  m as debuggerRequested,
+  p as denyPermissions,
+  x as isAllowedExternal,
+  S as isAllowedNavigation,
+  a as isDevToolsKey,
+  u as lockDownWindow,
+  w as refuseDebugLaunch,
+  n as registerSessionStore,
+  r as shellId
+};

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
+};