@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/providers-CRuaD8bi.js

@@ -0,0 +1,424 @@
+var Q = Object.defineProperty;
+var Z = (e, s, t) => s in e ? Q(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var O = (e, s, t) => Z(e, typeof s != "symbol" ? s + "" : s, t);
+import { jsx as z, jsxs as $ } from "react/jsx-runtime";
+import { useThree as ee, useLoader as te, useFrame as _ } from "@react-three/fiber";
+import { useMemo as g, useEffect as B, useRef as y, useState as W } from "react";
+import * as d from "three";
+import { R as se } from "./uv-DJU_XfmN.js";
+import { c as Y, b as L } from "./selectors-BvJepq6H.js";
+import { T as ne, s as H } from "./textures-BVwo9Z7z.js";
+import { z as re, A as ae, C as oe, D as V, F as ie, j as E, G as U, S as ce, I as le } from "./index-CKRN-xJp.js";
+import { p as ue, S as de, r as fe, F as he, L as me, R as ve, a as pe, b as xe, O as ge, I as Te } from "./landmarkMask-DHivVjJm.js";
+import { u as X } from "./landmarks-DtCAFV_m.js";
+const K = (e = 1, s = 1) => {
+  const t = new d.DataTexture(
+    new Uint8Array(e * s),
+    e,
+    s,
+    d.RedFormat,
+    d.UnsignedByteType
+  );
+  return t.minFilter = d.NearestFilter, t.magFilter = d.NearestFilter, t.generateMipmaps = !1, t.flipY = !1, t.unpackAlignment = 1, t.needsUpdate = !0, t;
+}, Me = (e, s) => {
+  const t = e.image;
+  if (t.width !== s.width || t.height !== s.height) {
+    e.dispose();
+    const r = K(s.width, s.height);
+    return r.image.data.set(s.indices), r.needsUpdate = !0, r;
+  }
+  return t.data.set(s.indices), e.needsUpdate = !0, e;
+}, ye = (e) => {
+  const s = g(
+    () => ({ texture: K(), version: -1, mask: null }),
+    []
+  );
+  return B(() => () => s.texture.dispose(), [s]), { holder: s, sync: () => (e && (s.mask !== e || s.version !== e.version) && (s.texture = Me(s.texture, e), s.mask = e, s.version = e.version), s.texture) };
+}, Ee = ({
+  space: e = "feed",
+  mirrored: s = !1,
+  maskWidth: t,
+  maskHeight: r,
+  feedWidth: n,
+  feedHeight: a,
+  zoom: o = 1
+}, l = new d.Matrix3()) => {
+  let i = 1, c = 1;
+  if (e === "source") {
+    const m = re(
+      { width: t, height: r },
+      { width: n, height: a },
+      "cover",
+      o
+    );
+    m && (i = n / m.drawWidth, c = a / m.drawHeight);
+  }
+  const u = s ? -i : i, f = 0.5 - 0.5 * u, h = -c, v = 0.5 + 0.5 * c;
+  return l.set(u, 0, f, 0, h, v, 0, 0, 1);
+}, be = 4, Se = `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}`, Re = `
+uniform sampler2D cameraTexture;
+uniform sampler2D maskTexture;
+uniform sampler2D designTexture;
+uniform float useDesign;
+uniform vec4 labels;
+uniform float labelCount;
+uniform float invert;
+uniform vec3 tint;
+uniform float opacity;
+uniform float blendMode;
+uniform float feather;
+uniform vec2 maskTexel;
+uniform mat3 maskTransform;
+varying vec2 vUv;
+
+float member(vec2 uv) {
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return 0.0;
+  float index = floor(texture2D(maskTexture, uv).r * 255.0 + 0.5);
+  float m = 0.0;
+  if (labelCount > 0.5 && abs(index - labels.x) < 0.5) m = 1.0;
+  if (labelCount > 1.5 && abs(index - labels.y) < 0.5) m = 1.0;
+  if (labelCount > 2.5 && abs(index - labels.z) < 0.5) m = 1.0;
+  if (labelCount > 3.5 && abs(index - labels.w) < 0.5) m = 1.0;
+  return invert > 0.5 ? 1.0 - m : m;
+}
+
+void main() {
+  vec2 maskUv = (maskTransform * vec3(vUv, 1.0)).xy;
+  float coverage;
+  if (feather > 0.0) {
+    vec2 step = maskTexel * feather;
+    coverage = 0.0;
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        coverage += member(maskUv + vec2(float(x), float(y)) * step);
+      }
+    }
+    coverage /= 9.0;
+  } else {
+    coverage = member(maskUv);
+  }
+
+  vec3 base = texture2D(cameraTexture, vUv).rgb;
+  vec4 design = useDesign > 0.5 ? texture2D(designTexture, vUv) : vec4(1.0);
+  vec3 paint = tint * design.rgb;
+  vec3 blended = blendMode < 0.5
+    ? paint
+    : blendMode < 1.5
+      ? base * paint
+      : blendMode < 2.5
+        ? 1.0 - (1.0 - base) * (1.0 - paint)
+        : mix(2.0 * base * paint, 1.0 - 2.0 * (1.0 - base) * (1.0 - paint), step(0.5, base));
+
+  gl_FragColor = vec4(blended, coverage * opacity * design.a);
+  #include <colorspace_fragment>
+}`;
+let A = null;
+const j = () => (A || (A = new d.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1), A.needsUpdate = !0), A), Ae = () => {
+  const e = {
+    cameraTexture: { value: null },
+    maskTexture: { value: null },
+    designTexture: { value: j() },
+    useDesign: { value: 0 },
+    labels: { value: new d.Vector4(-1, -1, -1, -1) },
+    labelCount: { value: 0 },
+    invert: { value: 0 },
+    tint: { value: new d.Color() },
+    opacity: { value: 1 },
+    blendMode: { value: 0 },
+    feather: { value: 0 },
+    maskTexel: { value: new d.Vector2(1, 1) },
+    maskTransform: { value: new d.Matrix3() }
+  };
+  return new d.ShaderMaterial({
+    uniforms: e,
+    vertexShader: Se,
+    fragmentShader: Re,
+    transparent: !0,
+    depthTest: !1,
+    depthWrite: !1,
+    toneMapped: !1,
+    side: d.DoubleSide
+  });
+}, _e = (e, s) => ue(s).map((t) => e ? e.labels.indexOf(t) : -1).filter((t) => t >= 0).slice(0, be), q = (e, s) => e && e.version > 0 ? _e(e, s) : [], we = (e, {
+  cameraTexture: s,
+  maskTexture: t,
+  mask: r,
+  settings: n,
+  designTexture: a = null,
+  feedWidth: o = 0,
+  feedHeight: l = 0
+}) => {
+  const i = e.uniforms, c = q(r, n.label);
+  i.cameraTexture.value = s, i.maskTexture.value = t, i.designTexture.value = a ?? j(), i.useDesign.value = a ? 1 : 0, i.labels.value.set(c[0] ?? -1, c[1] ?? -1, c[2] ?? -1, c[3] ?? -1), i.labelCount.value = c.length, i.invert.value = n.invert ? 1 : 0, i.tint.value.set(n.color), i.opacity.value = n.opacity, i.blendMode.value = de.indexOf(n.blendMode), i.feather.value = n.feather;
+  const u = (r == null ? void 0 : r.width) ?? 1, f = (r == null ? void 0 : r.height) ?? 1;
+  return i.maskTexel.value.set(1 / u, 1 / f), Ee(
+    {
+      space: (r == null ? void 0 : r.space) ?? "feed",
+      mirrored: n.mirrored,
+      maskWidth: u,
+      maskHeight: f,
+      feedWidth: o,
+      feedHeight: l
+    },
+    i.maskTransform.value
+  ), e;
+}, Ce = (e) => {
+  const s = g(Ae, []);
+  return B(() => () => s.dispose(), [s]), we(s, e), s;
+}, Qe = ({
+  mask: e,
+  texture: s,
+  material: t,
+  renderOrder: r = se.BACKGROUND + 10,
+  visible: n = !0,
+  ...a
+}) => {
+  const o = fe(a), { camera: l, size: i } = ee(), c = Y() ?? null, u = te(
+    d.TextureLoader,
+    typeof s == "string" ? s : ne
+  ), f = typeof s == "string" ? u : s ?? null;
+  f && f.colorSpace !== d.SRGBColorSpace && (f.colorSpace = d.SRGBColorSpace, f.needsUpdate = !0);
+  const { holder: h, sync: v } = ye(e), m = c == null ? void 0 : c.image, T = (m == null ? void 0 : m.width) ?? 0, b = (m == null ? void 0 : m.height) ?? 0, M = Ce({
+    cameraTexture: c,
+    maskTexture: h.texture,
+    mask: e,
+    settings: o,
+    designTexture: f,
+    feedWidth: T,
+    feedHeight: b
+  }), S = y(null), [, R] = W(0);
+  _(() => {
+    const p = v();
+    S.current !== p && (S.current = p, M.uniforms.maskTexture.value = p, R((N) => N + 1));
+  });
+  const w = g(() => {
+    const p = l;
+    if (!p.isPerspectiveCamera) return [10, 10];
+    const N = (p.position.z || 5) + 1, D = 2 * Math.tan(p.fov * Math.PI / 360) * N;
+    return [D * (i.width / i.height), D];
+  }, [l, i]);
+  if (!c || !n) return null;
+  const J = {
+    cameraTexture: c,
+    maskTexture: h.texture,
+    maskTransform: M.uniforms.maskTransform.value,
+    // Empty until the mask has data, exactly like the built-in material.
+    labelIndices: q(e, o.label),
+    mask: e,
+    settings: o
+  }, C = t ? typeof t == "function" ? t(J) : t : M, I = C instanceof d.Material ? C : void 0;
+  return /* @__PURE__ */ z("group", { position: [0, 0, -1], children: /* @__PURE__ */ $(
+    "mesh",
+    {
+      renderOrder: r,
+      frustumCulled: !1,
+      material: I,
+      children: [
+        /* @__PURE__ */ z("planeGeometry", { args: w }),
+        I ? null : C
+      ]
+    },
+    I ? "instance" : "node"
+  ) });
+}, Ie = {
+  left: {
+    /** Iris center. */
+    center: 473,
+    /** Iris ring: outer, top, inner, bottom (image order: right, up, left, down for the left eye). */
+    ring: [474, 475, 476, 477],
+    innerCorner: 362,
+    outerCorner: 263,
+    upperLid: 386,
+    lowerLid: 374
+  },
+  right: {
+    center: 468,
+    ring: [469, 470, 471, 472],
+    innerCorner: 133,
+    outerCorner: 33,
+    upperLid: 159,
+    lowerLid: 145
+  }
+}, Ne = 478, Oe = 0.2, x = () => ({ x: 0, y: 0, z: 0 }), G = (e) => ({
+  side: e,
+  detected: !1,
+  center: x(),
+  trackerCenter: { x: 0, y: 0, z: 0 },
+  ring: [x(), x(), x(), x()],
+  radius: 0,
+  eyeCenter: x(),
+  eyeWidth: 0,
+  openness: 0,
+  offset: { x: 0, y: 0 },
+  confidence: 0
+}), Ze = (e = 0) => ({
+  version: 0,
+  timestampMs: 0,
+  faceIndex: e,
+  detected: !1,
+  held: !1,
+  confidence: 1,
+  left: G("left"),
+  right: G("right")
+}), F = (e, s) => {
+  e.x = s.x, e.y = s.y, e.z = s.z;
+}, k = (e) => Math.max(-1, Math.min(1, e)), P = (e, s, t, r = 1, n = !1) => {
+  const a = Ie[ae(s, n)];
+  if (!e || e.length < Ne)
+    return t.detected = !1, t.confidence = 0, !1;
+  const o = e[a.center];
+  F(t.center, o), oe(o, t.trackerCenter);
+  for (let h = 0; h < 4; h += 1) F(t.ring[h], e[a.ring[h]]);
+  t.radius = Math.abs(t.ring[0].x - t.ring[2].x) / 2;
+  const l = e[a.innerCorner], i = e[a.outerCorner];
+  t.eyeCenter.x = (l.x + i.x) / 2, t.eyeCenter.y = (l.y + i.y) / 2, t.eyeCenter.z = (l.z + i.z) / 2, t.eyeWidth = Math.hypot(l.x - i.x, l.y - i.y);
+  const c = Math.abs(e[a.lowerLid].y - e[a.upperLid].y);
+  t.openness = t.eyeWidth > 0 ? c / t.eyeWidth : 0;
+  const u = t.eyeWidth / 2, f = n ? -1 : 1;
+  return t.offset.x = u > 0 ? k(f * (o.x - t.eyeCenter.x) / u) : 0, t.offset.y = u > 0 ? k((t.eyeCenter.y - o.y) / u) : 0, t.detected = !0, t.confidence = Math.max(0, Math.min(1, t.openness / Oe)) * r, !0;
+}, $e = (e, s, t, r = {}) => {
+  const n = r.held ?? !1, a = r.faceConfidence ?? (n ? 0 : 1), o = r.mirrored ?? !1;
+  e.faceIndex = r.faceIndex ?? e.faceIndex;
+  const l = P(s, "left", e.left, a, o), i = P(s, "right", e.right, a, o);
+  return e.detected = l && i, e.held = e.detected && n, e.confidence = e.detected ? a : 0, e.timestampMs = t, e.version += 1, e;
+}, Le = () => ({ x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0, sampleMs: 0, seen: !1 });
+class et {
+  constructor(s = 250) {
+    O(this, "slots", {});
+    O(this, "maxGapMs");
+    this.maxGapMs = s;
+  }
+  reset() {
+    this.slots = {};
+  }
+  /** Record a fresh inference sample for `key` (e.g. "left"). */
+  observe(s, t, r) {
+    const n = this.slots[s] ?? (this.slots[s] = Le()), a = (r - n.sampleMs) / 1e3;
+    n.seen && a > 0 && a * 1e3 <= this.maxGapMs ? (n.vx = 0.5 * n.vx + 0.5 * ((t.x - n.x) / a), n.vy = 0.5 * n.vy + 0.5 * ((t.y - n.y) / a), n.vz = 0.5 * n.vz + 0.5 * ((t.z - n.z) / a)) : (n.vx = 0, n.vy = 0, n.vz = 0), n.x = t.x, n.y = t.y, n.z = t.z, n.sampleMs = r, n.seen = !0;
+  }
+  /** Write the extrapolated position of `key` into `out`; a no-op before the first sample. */
+  apply(s, t, r, n) {
+    const a = this.slots[s];
+    if (!a || !a.seen || r <= 0) return n;
+    const o = Math.max(0, Math.min(t - a.sampleMs, r)) / 1e3;
+    return n.x = a.x + a.vx * o, n.y = a.y + a.vy * o, n.z = a.z + a.vz * o, n;
+  }
+}
+const Ue = ["bg", "face_skin", "brows", "eyes", "lips", "mouth"], De = [
+  { label: "face_skin", polygons: [he] },
+  { label: "brows", polygons: [me, ve] },
+  { label: "eyes", polygons: [pe, xe] },
+  { label: "lips", polygons: [ge] },
+  { label: "mouth", polygons: [Te] }
+], ze = (e, s, { regions: t, clear: r = !0 } = {}, n = []) => {
+  r && V(e), De.forEach(({ label: a, polygons: o }) => {
+    if (t && !t.includes(a)) return;
+    const l = e.labels.indexOf(a);
+    l < 0 || o.forEach(
+      (i) => ie(e, s, i, l, n)
+    );
+  });
+}, Ge = (e) => {
+  const s = e == null ? void 0 : e.image, t = (s == null ? void 0 : s.width) ?? 0, r = (s == null ? void 0 : s.height) ?? 0;
+  return t > 0 && r > 0 ? { width: t, height: r } : { width: 1, height: 1 };
+}, Fe = (e, s) => {
+  const t = s / Math.max(e.width, e.height, 1);
+  return {
+    width: Math.max(1, Math.round(e.width * t)),
+    height: Math.max(1, Math.round(e.height * t))
+  };
+}, tt = ({
+  faceIndex: e = "all",
+  regions: s,
+  resolution: t = 256,
+  maxUpdateFps: r,
+  holdMs: n = 250,
+  predictMs: a = 0
+} = {}) => {
+  const o = L(E.FACE_TRACKER), l = Y(), i = Ge(l), c = Fe(i, t), u = g(
+    () => U(c.width, c.height, Ue),
+    [c.width, c.height]
+  ), f = y([]), h = y(-1 / 0), v = y(null);
+  v.current || (v.current = new le({ holdMs: n, predictMs: a }));
+  const m = v.current;
+  return m.setOptions({ holdMs: n, predictMs: a }), _((T) => {
+    var R;
+    if (H(T.clock.elapsedTime, h.current, r)) return;
+    h.current = T.clock.elapsedTime;
+    const b = ((R = o == null ? void 0 : o.detectionResults) == null ? void 0 : R.faceLandmarks) ?? [], M = e === "all" ? b : [b[e] ?? []], S = m.update(M, T.clock.elapsedTime * 1e3);
+    V(u), S.forEach(
+      (w) => ze(u, w, { regions: s, clear: !1 }, f.current)
+    ), u.version += 1;
+  }), u;
+}, ke = ["bg", "person"], st = ({
+  maxUpdateFps: e = 15,
+  active: s = !0
+} = {}) => {
+  X(E.BACKGROUND_SEGMENTATION, { type: "portrait" }, s);
+  const t = L(E.BACKGROUND_SEGMENTATION), r = g(() => U(1, 1, ke), []), n = y(-1 / 0);
+  return _((a) => {
+    var c;
+    if (H(a.clock.elapsedTime, n.current, e)) return;
+    const o = (c = t == null ? void 0 : t.getRawSegmentationData) == null ? void 0 : c.call(t);
+    if (!(o != null && o.maskData) || o.width <= 0 || o.height <= 0) return;
+    n.current = a.clock.elapsedTime, (r.width !== o.width || r.height !== o.height) && (r.width = o.width, r.height = o.height, r.indices = new Uint8Array(o.width * o.height));
+    const l = o.maskData, i = r.indices;
+    for (let u = 0; u < i.length; u += 1) i[u] = l[u] > 127 ? 0 : 1;
+    r.version += 1, r.timestampMs = o.timestampMs;
+  }), r;
+}, Pe = ({
+  active: e = !0,
+  ...s
+} = {}) => {
+  const { ready: t, error: r } = X(
+    E.SEMANTIC_SEGMENTATION,
+    s,
+    e
+  ), n = L(E.SEMANTIC_SEGMENTATION), a = s.preset ?? "hair", o = g(
+    () => U(1, 1, ce[a].labels),
+    [a]
+  ), [l, i] = W({ status: "loading", error: null });
+  _(() => {
+    const h = (n == null ? void 0 : n.getStatus()) ?? "loading", v = (n == null ? void 0 : n.getError()) ?? null;
+    (h !== l.status || v !== l.error) && i({ status: h, error: v });
+  });
+  const c = (n == null ? void 0 : n.getMask()) ?? o, u = r ?? l.error, f = u ? "error" : t ? l.status : "loading";
+  return { mask: c, status: f, error: u, labels: c.labels };
+}, nt = (e = {}) => Pe({ ...e, preset: "hair" });
+export {
+  De as F,
+  et as I,
+  be as M,
+  ke as P,
+  Qe as S,
+  Ie as a,
+  Ne as b,
+  Ze as c,
+  nt as d,
+  st as e,
+  Pe as f,
+  Oe as g,
+  P as h,
+  G as i,
+  Re as j,
+  Se as k,
+  Ae as l,
+  _e as m,
+  we as n,
+  Ce as o,
+  K as p,
+  Me as q,
+  q as r,
+  ye as s,
+  Fe as t,
+  $e as u,
+  Ee as v,
+  ze as w,
+  tt as x,
+  Ue as y
+};

package/dist/quality/XRQualityController.d.ts

@@ -0,0 +1,25 @@
+import { XRQualityConfigInput, XRQualitySignals, XRQualityState } from './types';
+/** Static device signals (memory, cores) read once. */
+export declare const readDeviceSignals: () => Pick<XRQualitySignals, "deviceMemoryGb" | "hardwareConcurrency">;
+export type XRQualityControllerProps = {
+    /** Partial config merged over the defaults (`resolveQualityConfig`). */
+    config?: XRQualityConfigInput;
+    /** Externally supplied thermal state (a native shell can forward the OS value). */
+    thermal?: XRQualitySignals["thermal"];
+    /**
+     * Called whenever a different tier is applied (automatic or manual). The
+     * floor-level `signals.thermal === "suspected"` flag changes no tier, so it
+     * does not fire this; read `useXRQuality().signals` to react to it.
+     */
+    onDecision?: (state: XRQualityState) => void;
+};
+/**
+ * Samples main-thread frame time, tracker inference and memory on
+ * `budget.sampleMs`, steps the pure controller, publishes the state to the
+ * session store and applies the tier: `targetFps` + `analysisScale` through
+ * the session perf config, `renderScale` through `<XRScene>` (which reads
+ * the state), and `camRes` only when the tier sets `rebindCamera`. Mounted by
+ * `<XRProvider>` by default; mount it yourself with `quality={false}` on the
+ * provider to place it or configure it differently.
+ */
+export declare const XRQualityController: ({ config, thermal, onDecision }: XRQualityControllerProps) => null;

package/dist/quality/controller.d.ts

@@ -0,0 +1,33 @@
+import { XRPerformanceBudget, XRQualityConfig, XRQualityConfigInput, XRQualityReason, XRQualitySignals, XRQualityState, XRQualityTier } from './types';
+export declare const DEFAULT_QUALITY_TIERS: XRQualityTier[];
+export declare const DEFAULT_PERFORMANCE_BUDGET: XRPerformanceBudget;
+export declare const DEFAULT_QUALITY_CONFIG: XRQualityConfig;
+export declare const EMPTY_QUALITY_SIGNALS: XRQualitySignals;
+/** Validate a tier; invalid knobs are dropped, out-of-range ones clamped. */
+export declare const resolveQualityTier: (tier: Partial<XRQualityTier>, index: number) => XRQualityTier;
+export declare const resolvePerformanceBudget: (budget?: Partial<XRPerformanceBudget>) => XRPerformanceBudget;
+/** Validate a partial config into a complete, serializable one. */
+export declare const resolveQualityConfig: (config?: XRQualityConfigInput) => XRQualityConfig;
+/** Starting tier from static device signals: low-memory / few-core devices start one step down. */
+export declare const resolveInitialTierIndex: (config: XRQualityConfig, signals: XRQualitySignals) => number;
+export declare const createQualityState: (config: XRQualityConfig, signals?: XRQualitySignals, now?: number) => XRQualityState;
+/** Why a sample is over budget, most severe first; `null` when within budget. */
+export declare const judgeSample: (signals: XRQualitySignals, budget: XRPerformanceBudget) => Exclude<XRQualityReason, "init" | "recovered" | "manual" | "locked" | "reset"> | null;
+/**
+ * One controller step. Pure: returns the next state (same object when
+ * nothing changed). Bounded to `[maxTier, minTier]`, hysteretic (streaks),
+ * rate-limited (cooldown), reversible (steps back up after `upgradeAfter`
+ * good samples), and inert while `locked` or `adaptive: false`.
+ */
+export declare const stepQualityController: (state: XRQualityState, signals: XRQualitySignals, config: XRQualityConfig, now: number) => XRQualityState;
+/** Manual tier selection (does not lock). */
+export declare const setQualityTier: (state: XRQualityState, config: XRQualityConfig, ref: number | string, now: number) => XRQualityState;
+export declare const lockQuality: (state: XRQualityState, config: XRQualityConfig, locked: boolean, now: number) => XRQualityState;
+/**
+ * The tier the controller must apply now, or `null` when `lastApplied` is
+ * already it. Compares tier identity (the decision may have been written to
+ * the store by `useXRQuality().setTier` between two samples, so comparing
+ * decisions would miss it).
+ */
+export declare const tierToApply: (state: XRQualityState, lastApplied: XRQualityTier | null) => XRQualityTier | null;
+export declare const resetQuality: (config: XRQualityConfig, signals: XRQualitySignals, now: number) => XRQualityState;

package/dist/quality/index.d.ts

@@ -0,0 +1,6 @@
+export type { XRPerformanceBudget, XRQualityConfig, XRQualityConfigInput, XRQualityDecision, XRQualityReason, XRQualitySignals, XRQualityState, XRQualityTier, } from './types';
+export { XRQualityController, readDeviceSignals } from './XRQualityController';
+export type { XRQualityControllerProps } from './XRQualityController';
+export { useXRQuality } from './useXRQuality';
+export type { UseXRQualityResult } from './useXRQuality';
+export { DEFAULT_PERFORMANCE_BUDGET, DEFAULT_QUALITY_CONFIG, DEFAULT_QUALITY_TIERS, EMPTY_QUALITY_SIGNALS, createQualityState, judgeSample, lockQuality, resetQuality, resolveInitialTierIndex, resolvePerformanceBudget, resolveQualityConfig, resolveQualityTier, setQualityTier, stepQualityController, tierToApply, } from './controller';

package/dist/quality/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * One quality level. Every knob is optional; an omitted knob keeps the
+ * session's own value. Tiers are plain JSON so they can be persisted.
+ */
+export type XRQualityTier = {
+    name: string;
+    /** Inference cap applied to every tracker without its own `targetFps`. */
+    targetFps?: number;
+    /** Multiplier on the renderer's device pixel ratio cap (0.25..1). */
+    renderScale?: number;
+    /** Multiplier on every model's analysis resolution (0.25..1). */
+    analysisScale?: number;
+    /** Camera capture width; applied only when `rebindCamera` is true (a rebind re-opens the camera). */
+    camRes?: number;
+    /** Allow this tier to re-open the webcam to apply `camRes`. Default false. */
+    rebindCamera?: boolean;
+};
+/** Thresholds the controller judges samples against. Plain JSON. */
+export type XRPerformanceBudget = {
+    /** Frame time above which a sample is "bad" (ms). Default 1000 / 24. */
+    maxFrameMs: number;
+    /** Total tracker inference per frame above which a sample is "bad" (ms). Default 24. */
+    maxInferenceMs: number;
+    /** JS heap usage above which a sample is "bad" (MB); `null` ignores memory. Default null. */
+    maxMemoryMb: number | null;
+    /** Sampling period (ms). Default 1000. */
+    sampleMs: number;
+    /** Consecutive bad samples before stepping down. Default 2. */
+    downgradeAfter: number;
+    /** Consecutive good samples (frame time under `maxFrameMs × upgradeHeadroom`) before stepping up. Default 6. */
+    upgradeAfter: number;
+    /** A "good" sample must leave this much headroom (0..1 of `maxFrameMs`). Default 0.75. */
+    upgradeHeadroom: number;
+    /** Minimum time between two automatic changes (ms). Default 4000. */
+    cooldownMs: number;
+};
+/** What the controller measured in one sample. */
+export type XRQualitySignals = {
+    /** Mean main-thread frame time over the sample (ms); `null` before the first sample. */
+    frameMs: number | null;
+    /** Frames per second over the sample. */
+    fps: number | null;
+    /** Sum of the last inference of every running model (ms). */
+    inferenceMs: number | null;
+    /** Feed frames per second the session blitted. */
+    feedFps: number | null;
+    /** JS heap in use (MB) where `performance.memory` exists. */
+    memoryMb: number | null;
+    /** `navigator.deviceMemory` (GB) where exposed. */
+    deviceMemoryGb: number | null;
+    hardwareConcurrency: number | null;
+    /**
+     * Thermal state. Browsers expose none, so this is `"unknown"` unless the
+     * app supplies one (a native shell can); `"suspected"` is set by the
+     * controller when frame time keeps degrading at the lowest tier.
+     */
+    thermal: "unknown" | "nominal" | "suspected" | "critical";
+};
+export type XRQualityReason = "init" | "frame-time" | "inference" | "memory" | "thermal" | "recovered" | "manual" | "locked" | "reset";
+export type XRQualityDecision = {
+    /** Index into `tiers`. */
+    index: number;
+    tier: XRQualityTier;
+    reason: XRQualityReason;
+    /** `performance.now()` of the decision. */
+    at: number;
+};
+/** Controller state; serializable except for nothing (plain data). */
+export type XRQualityState = {
+    index: number;
+    /** When true the controller stops adjusting; `setTier` still works. */
+    locked: boolean;
+    badStreak: number;
+    goodStreak: number;
+    lastChangeAt: number;
+    decision: XRQualityDecision;
+    /** Last decisions, newest first (bounded). */
+    history: XRQualityDecision[];
+    signals: XRQualitySignals;
+};
+export type XRQualityConfig = {
+    /** Ordered best → worst. Default `DEFAULT_QUALITY_TIERS`. */
+    tiers: XRQualityTier[];
+    budget: XRPerformanceBudget;
+    /** Start here (index or name); default: picked from device signals. */
+    initialTier?: number | string;
+    /** The controller may step down to this tier at most (index or name). Default the last. */
+    minTier?: number | string;
+    /** The controller may step up to this tier at most. Default the first. */
+    maxTier?: number | string;
+    /** `false` keeps the initial tier and never adjusts (still observable). Default true. */
+    adaptive: boolean;
+    /** Bound of `history`. Default 20. */
+    historySize: number;
+};
+/** What creators pass: everything optional, tiers and budget partial. `resolveQualityConfig` fills it in. */
+export type XRQualityConfigInput = Partial<Omit<XRQualityConfig, "tiers" | "budget">> & {
+    tiers?: Array<Partial<XRQualityTier>>;
+    budget?: Partial<XRPerformanceBudget>;
+};

package/dist/quality/useXRQuality.d.ts

@@ -0,0 +1,28 @@
+import { XRQualityConfigInput, XRQualityDecision, XRQualitySignals, XRQualityState, XRQualityTier } from './types';
+export type UseXRQualityResult = {
+    /** Current tier (`null` until the controller publishes). */
+    tier: XRQualityTier | null;
+    index: number;
+    tiers: XRQualityTier[];
+    decision: XRQualityDecision | null;
+    history: XRQualityDecision[];
+    signals: XRQualitySignals | null;
+    locked: boolean;
+    /** Pick a tier by index or name (does not lock; the controller may move again after the cooldown). */
+    setTier: (ref: number | string) => void;
+    /** Freeze the current tier (`lock()`), or let the controller adjust again (`unlock()`). */
+    lock: () => void;
+    unlock: () => void;
+    /** Back to the initial tier for this device; clears the lock. */
+    reset: () => void;
+    state: XRQualityState | null;
+};
+/**
+ * Observe and steer adaptive quality. The controller (mounted by
+ * `<XRProvider>` by default) publishes its state AND its resolved config to
+ * the session store; this hook reads both, so `tiers` and name-based
+ * `setTier("medium")` resolve against the provider's tiers without passing
+ * the config again. Manual decisions are written back through the store and
+ * applied by the controller on its next sample.
+ */
+export declare const useXRQuality: (config?: XRQualityConfigInput) => UseXRQualityResult;

package/dist/render/layerStack.d.ts

@@ -0,0 +1,29 @@
+export type LayerDomain = "group" | "screen2d" | "scene3d" | "webgl" | "shader" | "custom";
+export type LayerNode = {
+    id: string;
+    domain: LayerDomain;
+    type: string;
+    label: string;
+    enabled: boolean;
+    visible: boolean;
+    locked?: boolean;
+    expanded?: boolean;
+    renderOrder: number;
+    children?: LayerNode[];
+    meta?: Record<string, unknown>;
+};
+export declare const LAYER_STACK_BASE_RENDER_ORDER = 1000;
+export declare function normalizeLayerStack(layers: LayerNode[], baseRenderOrder?: number): {
+    renderOrder: number;
+    id: string;
+    domain: LayerDomain;
+    type: string;
+    label: string;
+    enabled: boolean;
+    visible: boolean;
+    locked?: boolean;
+    expanded?: boolean;
+    children?: LayerNode[];
+    meta?: Record<string, unknown>;
+}[];
+export declare function moveLayerNode(layers: LayerNode[], activeId: string, overId: string): LayerNode[];