@nastechai-research/ui 0.13.2

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @nastechai-research/ui Changelog
+
+## 0.18.2
+
+Initial release under the `@nastechai-research` scope.

package/README.md

@@ -0,0 +1,21 @@
+# @nastechai-research/ui
+
+The shared design system for React UI @ Nastechai. Components, hooks, utils, fonts, overlays, and more.
+
+## Installation
+
+```bash
+npm install @nastechai-research/ui
+```
+
+## Usage
+
+```tsx
+import { Button } from '@nastechai-research/ui/ui/components/button'
+import { Spinner } from '@nastechai-research/ui/ui/components/spinner'
+import { Typography } from '@nastechai-research/ui/ui/components/typography/index'
+```
+
+## License
+
+MIT © Nastechai Research

package/dist/assets.d.ts

@@ -0,0 +1,38 @@
+interface StaticImageData {
+  src: string
+  height: number
+  width: number
+  blurDataURL?: string
+  blurWidth?: number
+  blurHeight?: number
+}
+
+declare module '*.jpg' {
+  const content: StaticImageData
+  export default content
+}
+
+declare module '*.jpeg' {
+  const content: StaticImageData
+  export default content
+}
+
+declare module '*.png' {
+  const content: StaticImageData
+  export default content
+}
+
+declare module '*.svg' {
+  const content: StaticImageData
+  export default content
+}
+
+declare module '*.gif' {
+  const content: StaticImageData
+  export default content
+}
+
+declare module '*.webp' {
+  const content: StaticImageData
+  export default content
+}

package/dist/fonts.d.ts

@@ -0,0 +1,6 @@
+/** CSS variable names for the design language fonts. Set automatically by fonts.css. */
+export declare const FONT_SANS = "--font-sans";
+export declare const FONT_MONO = "--font-mono";
+export declare const FONT_RULES_COMPRESSED = "--font-rules-compressed";
+export declare const FONT_RULES_EXPANDED = "--font-rules-expanded";
+export declare const FONT_MONDWEST = "--font-mondwest";

package/dist/fonts.js

@@ -0,0 +1,6 @@
+export const FONT_SANS = "--font-sans";
+export const FONT_MONO = "--font-mono";
+export const FONT_RULES_COMPRESSED = "--font-rules-compressed";
+export const FONT_RULES_EXPANDED = "--font-rules-expanded";
+export const FONT_MONDWEST = "--font-mondwest";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqIENTUyB2YXJpYWJsZSBuYW1lcyBmb3IgdGhlIGRlc2lnbiBsYW5ndWFnZSBmb250cy4gU2V0IGF1dG9tYXRpY2FsbHkgYnkgZm9udHMuY3NzLiAqL1xuZXhwb3J0IGNvbnN0IEZPTlRfU0FOUyA9ICctLWZvbnQtc2FucydcbmV4cG9ydCBjb25zdCBGT05UX01PTk8gPSAnLS1mb250LW1vbm8nXG5leHBvcnQgY29uc3QgRk9OVF9SVUxFU19DT01QUkVTU0VEID0gJy0tZm9udC1ydWxlcy1jb21wcmVzc2VkJ1xuZXhwb3J0IGNvbnN0IEZPTlRfUlVMRVNfRVhQQU5ERUQgPSAnLS1mb250LXJ1bGVzLWV4cGFuZGVkJ1xuZXhwb3J0IGNvbnN0IEZPTlRfTU9ORFdFU1QgPSAnLS1mb250LW1vbmR3ZXN0J1xuIl0sCiAgIm1hcHBpbmdzIjogIkFBQ08sYUFBTSxZQUFZO0FBQ2xCLGFBQU0sWUFBWTtBQUNsQixhQUFNLHdCQUF3QjtBQUM5QixhQUFNLHNCQUFzQjtBQUM1QixhQUFNLGdCQUFnQjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/hooks/use-below-breakpoint.d.ts

@@ -0,0 +1,2 @@
+/** True when viewport width is strictly below `px`. */
+export declare function useBelowBreakpoint(px: number): boolean;

package/dist/hooks/use-below-breakpoint.js

@@ -0,0 +1,17 @@
+"use client";
+import { useEffect, useState } from "react";
+export function useBelowBreakpoint(px) {
+  const query = `(max-width: ${px - 1}px)`;
+  const [matches, setMatches] = useState(
+    () => typeof window !== "undefined" ? window.matchMedia(query).matches : false
+  );
+  useEffect(() => {
+    const mql = window.matchMedia(query);
+    const sync = () => setMatches(mql.matches);
+    sync();
+    mql.addEventListener("change", sync);
+    return () => mql.removeEventListener("change", sync);
+  }, [query]);
+  return matches;
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IHVzZUVmZmVjdCwgdXNlU3RhdGUgfSBmcm9tICdyZWFjdCdcblxuLyoqIFRydWUgd2hlbiB2aWV3cG9ydCB3aWR0aCBpcyBzdHJpY3RseSBiZWxvdyBgcHhgLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVzZUJlbG93QnJlYWtwb2ludChweDogbnVtYmVyKSB7XG4gIGNvbnN0IHF1ZXJ5ID0gYChtYXgtd2lkdGg6ICR7cHggLSAxfXB4KWBcbiAgY29uc3QgW21hdGNoZXMsIHNldE1hdGNoZXNdID0gdXNlU3RhdGUoKCkgPT5cbiAgICB0eXBlb2Ygd2luZG93ICE9PSAndW5kZWZpbmVkJyA/IHdpbmRvdy5tYXRjaE1lZGlhKHF1ZXJ5KS5tYXRjaGVzIDogZmFsc2VcbiAgKVxuXG4gIHVzZUVmZmVjdCgoKSA9PiB7XG4gICAgY29uc3QgbXFsID0gd2luZG93Lm1hdGNoTWVkaWEocXVlcnkpXG4gICAgY29uc3Qgc3luYyA9ICgpID0+IHNldE1hdGNoZXMobXFsLm1hdGNoZXMpXG4gICAgc3luYygpXG4gICAgbXFsLmFkZEV2ZW50TGlzdGVuZXIoJ2NoYW5nZScsIHN5bmMpXG4gICAgcmV0dXJuICgpID0+IG1xbC5yZW1vdmVFdmVudExpc3RlbmVyKCdjaGFuZ2UnLCBzeW5jKVxuICB9LCBbcXVlcnldKVxuXG4gIHJldHVybiBtYXRjaGVzXG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBRUEsU0FBUyxXQUFXLGdCQUFnQjtBQUc3QixnQkFBUyxtQkFBbUIsSUFBWTtBQUM3QyxRQUFNLFFBQVEsZUFBZSxLQUFLLENBQUM7QUFDbkMsUUFBTSxDQUFDLFNBQVMsVUFBVSxJQUFJO0FBQUEsSUFBUyxNQUNyQyxPQUFPLFdBQVcsY0FBYyxPQUFPLFdBQVcsS0FBSyxFQUFFLFVBQVU7QUFBQSxFQUNyRTtBQUVBLFlBQVUsTUFBTTtBQUNkLFVBQU0sTUFBTSxPQUFPLFdBQVcsS0FBSztBQUNuQyxVQUFNLE9BQU8sTUFBTSxXQUFXLElBQUksT0FBTztBQUN6QyxTQUFLO0FBQ0wsUUFBSSxpQkFBaUIsVUFBVSxJQUFJO0FBQ25DLFdBQU8sTUFBTSxJQUFJLG9CQUFvQixVQUFVLElBQUk7QUFBQSxFQUNyRCxHQUFHLENBQUMsS0FBSyxDQUFDO0FBRVYsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/hooks/use-capped-frame.d.ts

@@ -0,0 +1,2 @@
+import type { RenderCallback } from '@react-three/fiber';
+export declare function useCappedFrame(cb: RenderCallback, max?: number): void;

package/dist/hooks/use-capped-frame.js

@@ -0,0 +1,15 @@
+"use client";
+import { useFrame, useThree } from "@react-three/fiber";
+import { useRef } from "react";
+export function useCappedFrame(cb, max) {
+  const last = useRef(performance.now());
+  const { size } = useThree();
+  const interval = 1e3 / (max ?? (size.width < 1024 ? 60 : 120));
+  useFrame((st, delta) => {
+    if (performance.now() - last.current > interval) {
+      last.current = performance.now();
+      cb(st, delta);
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IHVzZUZyYW1lLCB1c2VUaHJlZSB9IGZyb20gJ0ByZWFjdC10aHJlZS9maWJlcidcbmltcG9ydCB0eXBlIHsgUmVuZGVyQ2FsbGJhY2sgfSBmcm9tICdAcmVhY3QtdGhyZWUvZmliZXInXG5pbXBvcnQgeyB1c2VSZWYgfSBmcm9tICdyZWFjdCdcblxuZXhwb3J0IGZ1bmN0aW9uIHVzZUNhcHBlZEZyYW1lKGNiOiBSZW5kZXJDYWxsYmFjaywgbWF4PzogbnVtYmVyKSB7XG4gIGNvbnN0IGxhc3QgPSB1c2VSZWYocGVyZm9ybWFuY2Uubm93KCkpXG4gIGNvbnN0IHsgc2l6ZSB9ID0gdXNlVGhyZWUoKVxuICBjb25zdCBpbnRlcnZhbCA9IDFlMyAvIChtYXggPz8gKHNpemUud2lkdGggPCAxMDI0ID8gNjAgOiAxMjApKVxuXG4gIHVzZUZyYW1lKChzdCwgZGVsdGEpID0+IHtcbiAgICBpZiAocGVyZm9ybWFuY2Uubm93KCkgLSBsYXN0LmN1cnJlbnQgPiBpbnRlcnZhbCkge1xuICAgICAgbGFzdC5jdXJyZW50ID0gcGVyZm9ybWFuY2Uubm93KClcbiAgICAgIGNiKHN0LCBkZWx0YSlcbiAgICB9XG4gIH0pXG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBRUEsU0FBUyxVQUFVLGdCQUFnQjtBQUVuQyxTQUFTLGNBQWM7QUFFaEIsZ0JBQVMsZUFBZSxJQUFvQixLQUFjO0FBQy9ELFFBQU0sT0FBTyxPQUFPLFlBQVksSUFBSSxDQUFDO0FBQ3JDLFFBQU0sRUFBRSxLQUFLLElBQUksU0FBUztBQUMxQixRQUFNLFdBQVcsT0FBTyxRQUFRLEtBQUssUUFBUSxPQUFPLEtBQUs7QUFFekQsV0FBUyxDQUFDLElBQUksVUFBVTtBQUN0QixRQUFJLFlBQVksSUFBSSxJQUFJLEtBQUssVUFBVSxVQUFVO0FBQy9DLFdBQUssVUFBVSxZQUFZLElBQUk7QUFDL0IsU0FBRyxJQUFJLEtBQUs7QUFBQSxJQUNkO0FBQUEsRUFDRixDQUFDO0FBQ0g7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/hooks/use-confirm-delete.d.ts

@@ -0,0 +1,10 @@
+export declare function useConfirmDelete<TId>({ onDelete }: {
+    onDelete: (id: TId) => Promise<void>;
+}): {
+    readonly cancel: () => void;
+    readonly confirm: () => Promise<void>;
+    readonly isDeleting: boolean;
+    readonly isOpen: boolean;
+    readonly pendingId: TId | null;
+    readonly requestDelete: (id: TId) => void;
+};

package/dist/hooks/use-confirm-delete.js

@@ -0,0 +1,35 @@
+"use client";
+import { useCallback, useState } from "react";
+export function useConfirmDelete({
+  onDelete
+}) {
+  const [pendingId, setPendingId] = useState(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const requestDelete = useCallback((id) => {
+    setPendingId(id);
+  }, []);
+  const cancel = useCallback(() => {
+    if (!isDeleting) setPendingId(null);
+  }, [isDeleting]);
+  const confirm = useCallback(async () => {
+    if (pendingId === null) return;
+    const id = pendingId;
+    setIsDeleting(true);
+    try {
+      await onDelete(id);
+      setPendingId(null);
+    } catch {
+    } finally {
+      setIsDeleting(false);
+    }
+  }, [pendingId, onDelete]);
+  return {
+    cancel,
+    confirm,
+    isDeleting,
+    isOpen: pendingId !== null,
+    pendingId,
+    requestDelete
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/use-css-var-dims.d.ts

@@ -0,0 +1 @@
+export declare function useCssVarDims(name: string, ref: React.RefObject<HTMLElement | null>): void;

package/dist/hooks/use-css-var-dims.js

@@ -0,0 +1,29 @@
+"use client";
+import { useEffect } from "react";
+export function useCssVarDims(name, ref) {
+  useEffect(() => {
+    if (!ref.current) {
+      return;
+    }
+    const update = (width2, height2) => {
+      document.documentElement.style.setProperty(
+        `--${name}-width`,
+        `${width2}px`
+      );
+      document.documentElement.style.setProperty(
+        `--${name}-height`,
+        `${height2}px`
+      );
+    };
+    const { height, width } = ref.current.getBoundingClientRect();
+    update(width, height);
+    const ro = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        update(entry.contentRect.width, entry.contentRect.height);
+      }
+    });
+    ro.observe(ref.current);
+    return () => ro.disconnect();
+  }, [name, ref]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/use-gpu-tier.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tiers:
+ *  0 — no WebGL / software renderer / prefers-reduced-motion / WebGL ctx
+ *      creation failed / detection not yet run
+ *  1 — low-end GPU (integrated, mobile, or failed perf benchmark)
+ *  2 — capable GPU (discrete / high-end integrated)
+ *
+ * The atom starts **pessimistic** (`0`) and the probe is scheduled to run
+ * *after the first paint* (see `scheduleDetection` below), never synchronously
+ * at module-evaluation time.
+ *
+ * Why pessimistic + deferred:
+ *  - Every consumer gates its `<canvas>` / `THREE.WebGLRenderer` on `tier > 0`
+ *    (or `=== 2`). Starting at `0` means a consumer reading `$gpuTier` during
+ *    its first render never attempts to create a renderer before detection has
+ *    run, so the `THREE.WebGLRenderer: Error creating WebGL context` crash on
+ *    hardware where context creation fails cannot happen — the component
+ *    renders its fallback and upgrades once detection resolves to a capable
+ *    tier. (A previous version made the probe synchronous-at-module-load to
+ *    dodge this crash; the pessimistic default removes the crash without that
+ *    cost.)
+ *  - Probing WebGL is *expensive* on software renderers: creating a context
+ *    under SwiftShader / llvmpipe can block the main thread for hundreds of
+ *    milliseconds. Running it synchronously at module load stalled first paint
+ *    and produced a visible boot-time flash in apps that merely import this
+ *    hook (e.g. the Hermes dashboard backdrop). Deferring past first paint
+ *    keeps boot smooth; the tier just upgrades a frame or two later.
+ *  - For SSR the server keeps the default `0` and the client's first render
+ *    also reads `0`, so there is no hydration mismatch.
+ */
+export declare const $gpuTier: import("nanostores").PreinitializedWritableAtom<GpuTier> & object;
+export declare function useGpuTier(): GpuTier;
+type GpuTier = 0 | 1 | 2;
+export {};

package/dist/hooks/use-gpu-tier.js

@@ -0,0 +1,111 @@
+"use client";
+import { useStore } from "@nanostores/react";
+import { atom } from "nanostores";
+export const $gpuTier = atom(0);
+const SOFTWARE_PATTERNS = /swiftshader|llvmpipe|softpipe|software|microsoft basic/i;
+const LOW_END_PATTERNS = /intel.*hd|intel.*uhd|intel.*iris|mali|adreno\s?[1-5]|powervr|apple gpu/i;
+let detected = false;
+function detectGpuTier() {
+  if (detected || typeof window === "undefined") {
+    return;
+  }
+  detected = true;
+  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    return;
+  }
+  let gl = null;
+  try {
+    const canvas = document.createElement("canvas");
+    gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+  } catch {
+    return;
+  }
+  if (!gl) {
+    return;
+  }
+  const ext = gl.getExtension("WEBGL_debug_renderer_info");
+  const renderer = String(
+    ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER)
+  );
+  if (SOFTWARE_PATTERNS.test(renderer)) {
+    gl.getExtension("WEBGL_lose_context")?.loseContext();
+    return;
+  }
+  if (LOW_END_PATTERNS.test(renderer)) {
+    $gpuTier.set(1);
+    gl.getExtension("WEBGL_lose_context")?.loseContext();
+    return;
+  }
+  $gpuTier.set(2);
+  runBenchmark(gl).then((fps) => $gpuTier.set(fps < 30 ? 1 : 2)).catch(() => $gpuTier.set(1)).finally(() => gl?.getExtension("WEBGL_lose_context")?.loseContext());
+}
+function scheduleDetection() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.requestIdleCallback === "function") {
+    window.requestIdleCallback(() => detectGpuTier(), { timeout: 1e3 });
+  } else if (typeof window.requestAnimationFrame === "function") {
+    window.requestAnimationFrame(
+      () => window.requestAnimationFrame(() => detectGpuTier())
+    );
+  } else {
+    setTimeout(() => detectGpuTier(), 0);
+  }
+}
+scheduleDetection();
+function runBenchmark(gl) {
+  return new Promise((resolve) => {
+    const vs = gl.createShader(gl.VERTEX_SHADER);
+    const fs = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(
+      vs,
+      "attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}"
+    );
+    gl.shaderSource(
+      fs,
+      "precision highp float;uniform float t;void main(){float v=0.;for(int i=0;i<64;i++)v+=sin(float(i)*t*.01);gl_FragColor=vec4(v*.001);}"
+    );
+    gl.compileShader(vs);
+    gl.compileShader(fs);
+    const prog = gl.createProgram();
+    gl.attachShader(prog, vs);
+    gl.attachShader(prog, fs);
+    gl.linkProgram(prog);
+    gl.useProgram(prog);
+    const buf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+      gl.STATIC_DRAW
+    );
+    const a = gl.getAttribLocation(prog, "a");
+    gl.enableVertexAttribArray(a);
+    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0);
+    const uT = gl.getUniformLocation(prog, "t");
+    let frames = 0;
+    const start = performance.now();
+    const tick = () => {
+      gl.uniform1f(uT, frames);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+      gl.finish();
+      frames++;
+      if (performance.now() - start < 200) {
+        requestAnimationFrame(tick);
+      } else {
+        const elapsed = performance.now() - start;
+        gl.deleteProgram(prog);
+        gl.deleteShader(vs);
+        gl.deleteShader(fs);
+        gl.deleteBuffer(buf);
+        resolve(frames / elapsed * 1e3);
+      }
+    };
+    requestAnimationFrame(tick);
+  });
+}
+export function useGpuTier() {
+  return useStore($gpuTier);
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useStore } from '@nanostores/react'\nimport { atom } from 'nanostores'\n\n/**\n * Tiers:\n *  0 \u2014 no WebGL / software renderer / prefers-reduced-motion / WebGL ctx\n *      creation failed / detection not yet run\n *  1 \u2014 low-end GPU (integrated, mobile, or failed perf benchmark)\n *  2 \u2014 capable GPU (discrete / high-end integrated)\n *\n * The atom starts **pessimistic** (`0`) and the probe is scheduled to run\n * *after the first paint* (see `scheduleDetection` below), never synchronously\n * at module-evaluation time.\n *\n * Why pessimistic + deferred:\n *  - Every consumer gates its `<canvas>` / `THREE.WebGLRenderer` on `tier > 0`\n *    (or `=== 2`). Starting at `0` means a consumer reading `$gpuTier` during\n *    its first render never attempts to create a renderer before detection has\n *    run, so the `THREE.WebGLRenderer: Error creating WebGL context` crash on\n *    hardware where context creation fails cannot happen \u2014 the component\n *    renders its fallback and upgrades once detection resolves to a capable\n *    tier. (A previous version made the probe synchronous-at-module-load to\n *    dodge this crash; the pessimistic default removes the crash without that\n *    cost.)\n *  - Probing WebGL is *expensive* on software renderers: creating a context\n *    under SwiftShader / llvmpipe can block the main thread for hundreds of\n *    milliseconds. Running it synchronously at module load stalled first paint\n *    and produced a visible boot-time flash in apps that merely import this\n *    hook (e.g. the Hermes dashboard backdrop). Deferring past first paint\n *    keeps boot smooth; the tier just upgrades a frame or two later.\n *  - For SSR the server keeps the default `0` and the client's first render\n *    also reads `0`, so there is no hydration mismatch.\n */\nexport const $gpuTier = atom<GpuTier>(0)\n\nconst SOFTWARE_PATTERNS =\n  /swiftshader|llvmpipe|softpipe|software|microsoft basic/i\n\nconst LOW_END_PATTERNS =\n  /intel.*hd|intel.*uhd|intel.*iris|mali|adreno\\s?[1-5]|powervr|apple gpu/i\n\nlet detected = false\n\nfunction detectGpuTier() {\n  if (detected || typeof window === 'undefined') {\n    return\n  }\n\n  detected = true\n\n  // The atom already holds 0; the early returns below simply leave it there.\n  if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) {\n    return\n  }\n\n  let gl: null | WebGLRenderingContext = null\n\n  try {\n    const canvas = document.createElement('canvas')\n    gl = (canvas.getContext('webgl') ||\n      canvas.getContext('experimental-webgl')) as null | WebGLRenderingContext\n  } catch {\n    // Some sandboxed / hardened contexts throw on getContext rather than\n    // returning null (e.g. certain corporate browser policies). Treat as\n    // \"no WebGL available\".\n    return\n  }\n\n  if (!gl) {\n    return\n  }\n\n  const ext = gl.getExtension('WEBGL_debug_renderer_info')\n  const renderer = String(\n    ext\n      ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL)\n      : gl.getParameter(gl.RENDERER)\n  )\n\n  if (SOFTWARE_PATTERNS.test(renderer)) {\n    gl.getExtension('WEBGL_lose_context')?.loseContext()\n\n    return\n  }\n\n  if (LOW_END_PATTERNS.test(renderer)) {\n    $gpuTier.set(1)\n    gl.getExtension('WEBGL_lose_context')?.loseContext()\n\n    return\n  }\n\n  $gpuTier.set(2)\n\n  runBenchmark(gl)\n    .then(fps => $gpuTier.set(fps < 30 ? 1 : 2))\n    .catch(() => $gpuTier.set(1))\n    .finally(() => gl?.getExtension('WEBGL_lose_context')?.loseContext())\n}\n\n/**\n * Run detection once, *after* the first paint so the (potentially expensive)\n * WebGL probe never blocks initial render. Prefer `requestIdleCallback` so the\n * probe yields to rendering and input; fall back to a double\n * `requestAnimationFrame` (guarantees at least one painted frame) and finally\n * `setTimeout` where neither exists.\n */\nfunction scheduleDetection() {\n  if (typeof window === 'undefined') {\n    return\n  }\n\n  if (typeof window.requestIdleCallback === 'function') {\n    window.requestIdleCallback(() => detectGpuTier(), { timeout: 1000 })\n  } else if (typeof window.requestAnimationFrame === 'function') {\n    window.requestAnimationFrame(() =>\n      window.requestAnimationFrame(() => detectGpuTier())\n    )\n  } else {\n    setTimeout(() => detectGpuTier(), 0)\n  }\n}\n\nscheduleDetection()\n\nfunction runBenchmark(gl: WebGLRenderingContext): Promise<number> {\n  return new Promise(resolve => {\n    const vs = gl.createShader(gl.VERTEX_SHADER)!\n    const fs = gl.createShader(gl.FRAGMENT_SHADER)!\n    gl.shaderSource(\n      vs,\n      'attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}'\n    )\n    gl.shaderSource(\n      fs,\n      'precision highp float;uniform float t;void main(){float v=0.;for(int i=0;i<64;i++)v+=sin(float(i)*t*.01);gl_FragColor=vec4(v*.001);}'\n    )\n    gl.compileShader(vs)\n    gl.compileShader(fs)\n\n    const prog = gl.createProgram()!\n    gl.attachShader(prog, vs)\n    gl.attachShader(prog, fs)\n    gl.linkProgram(prog)\n    gl.useProgram(prog)\n\n    const buf = gl.createBuffer()\n    gl.bindBuffer(gl.ARRAY_BUFFER, buf)\n    gl.bufferData(\n      gl.ARRAY_BUFFER,\n      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),\n      gl.STATIC_DRAW\n    )\n    const a = gl.getAttribLocation(prog, 'a')\n    gl.enableVertexAttribArray(a)\n    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0)\n\n    const uT = gl.getUniformLocation(prog, 't')\n    let frames = 0\n    const start = performance.now()\n\n    const tick = () => {\n      gl.uniform1f(uT, frames)\n      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)\n      gl.finish()\n      frames++\n\n      if (performance.now() - start < 200) {\n        requestAnimationFrame(tick)\n      } else {\n        const elapsed = performance.now() - start\n        gl.deleteProgram(prog)\n        gl.deleteShader(vs)\n        gl.deleteShader(fs)\n        gl.deleteBuffer(buf)\n        resolve((frames / elapsed) * 1000)\n      }\n    }\n\n    requestAnimationFrame(tick)\n  })\n}\n\nexport function useGpuTier() {\n  return useStore($gpuTier)\n}\n\ntype GpuTier = 0 | 1 | 2\n"],
  "mappings": "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",
  "names": []
}


package/dist/hooks/use-render-loop.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Visibility- and intersection-aware render-loop helper for the WebGL
+ * overlays.
+ *
+ * The overlays were previously running fragment shaders at 60fps for the
+ * entire lifetime of the page — including when the tab was hidden, the
+ * canvas had been scrolled out of view, or the user had been idle for
+ * hours. On retina laptops the compositor cost of mix-blend-mode on a
+ * full-viewport canvas plus continuous WebGL rasterisation is enough to
+ * keep the GPU hot indefinitely, which is what manifests as "fans go
+ * crazy after 2 hours of idle".
+ *
+ * `runRenderLoop` wraps a frame callback so that it:
+ *
+ *   1. Pauses entirely when `document.hidden` is true (background tab,
+ *      minimised window, screen locked).
+ *   2. Pauses when the canvas's bounding rect is offscreen (we tell
+ *      `IntersectionObserver` to look at the canvas itself).
+ *   3. Optionally caps the frame rate via a min-interval — the previous
+ *      `gpuTier === 1 ? setTimeout(loop, 100) : raf` trick is preserved
+ *      and extended so even tier-2 GPUs cap at e.g. 30fps for overlays
+ *      that don't need 60.
+ *
+ * The callback receives the *delta* time in seconds since the last call
+ * (so `uTime` advances correctly across pauses without ever skipping
+ * forward by hours).
+ */
+interface RunRenderLoopOptions {
+    /** Element to observe with IntersectionObserver. When fully out of
+     *  view, the loop pauses. Pass the canvas element itself. */
+    el: Element;
+    /** Min ms between frames. 0 = no cap (uses requestAnimationFrame).
+     *  Anything > 0 uses setTimeout-driven scheduling. */
+    minIntervalMs?: number;
+    /** Frame callback. Receives the elapsed seconds since the previous
+     *  *executed* frame (not since the previous scheduled frame), so
+     *  uniforms keyed off this value will not jump after a long pause. */
+    onFrame: (deltaSeconds: number) => void;
+}
+export declare function runRenderLoop({ el, minIntervalMs, onFrame }: RunRenderLoopOptions): () => void;
+export {};

package/dist/hooks/use-render-loop.js

@@ -0,0 +1,63 @@
+"use client";
+export function runRenderLoop({
+  el,
+  minIntervalMs = 0,
+  onFrame
+}) {
+  let running = true;
+  let visible = !document.hidden;
+  let inView = true;
+  let last = performance.now();
+  let raf = 0;
+  let timer;
+  const onVisibility = () => {
+    visible = !document.hidden;
+    if (visible) {
+      last = performance.now();
+      schedule();
+    }
+  };
+  const io = new IntersectionObserver(
+    (entries) => {
+      const wasInView = inView;
+      inView = entries.some((e) => e.isIntersecting);
+      if (!wasInView && inView) {
+        last = performance.now();
+        schedule();
+      }
+    },
+    { threshold: 0 }
+  );
+  io.observe(el);
+  document.addEventListener("visibilitychange", onVisibility);
+  const tick = () => {
+    if (!running) return;
+    if (!visible || !inView) {
+      return;
+    }
+    const now = performance.now();
+    const delta = (now - last) / 1e3;
+    last = now;
+    onFrame(delta);
+    schedule();
+  };
+  function schedule() {
+    if (!running || !visible || !inView) return;
+    if (minIntervalMs > 0) {
+      timer = setTimeout(tick, minIntervalMs);
+    } else {
+      raf = requestAnimationFrame(tick);
+    }
+  }
+  schedule();
+  return () => {
+    running = false;
+    io.disconnect();
+    document.removeEventListener("visibilitychange", onVisibility);
+    cancelAnimationFrame(raf);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/use-smooth-controls.d.ts

@@ -0,0 +1,16 @@
+import { useControls } from 'leva';
+import { type WritableAtom } from 'nanostores';
+export declare function useSmoothControls<T extends Record<string, any>>(label: string, initialArgs: T, options?: UseSmoothControlsOptions, dependencies?: Parameters<typeof useControls>[3]): { [K in keyof T]: T[K] extends {
+    value: infer V;
+} ? V : never; };
+export declare const getControlAtom: <T = any>(label: string, key: string) => undefined | WritableAtom<T>;
+export declare const setControlValue: <T = any>(label: string, key: string, value: T, options?: {
+    animate?: boolean;
+    duration?: number;
+}) => void;
+type UseSmoothControlsOptions = Parameters<typeof useControls>[2] & {
+    duration?: number;
+    onRandomize?: () => void;
+    onReset?: () => void;
+};
+export {};