@oasiz/sdk 1.6.0 → 1.6.1

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/haptics.ts
+// src/character.ts
 function isDevelopment() {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return nodeEnv !== "production";
@@ -9,72 +9,1014 @@ function getBridgeWindow() {
   }
   return window;
 }
-function triggerHaptic(type) {
+function warnMissingBridge(methodName) {
+  if (isDevelopment()) {
+    console.warn(
+      "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
+    );
+  }
+}
+async function getPlayerCharacter() {
   const bridge = getBridgeWindow();
+  if (typeof bridge?.__oasizGetPlayerCharacter !== "function") {
+    warnMissingBridge("getPlayerCharacter");
+    return null;
+  }
+  try {
+    const result = await bridge.__oasizGetPlayerCharacter();
+    return result ?? null;
+  } catch (error) {
+    if (isDevelopment()) {
+      console.error("[oasiz/sdk] getPlayerCharacter failed:", error);
+    }
+    return null;
+  }
+}
+
+// src/haptics.ts
+function isDevelopment2() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
+function getBridgeWindow2() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function triggerHaptic(type) {
+  const bridge = getBridgeWindow2();
   if (typeof bridge?.triggerHaptic === "function") {
     bridge.triggerHaptic(type);
     return;
   }
-  if (isDevelopment()) {
+  if (isDevelopment2()) {
     console.warn(
       "[oasiz/sdk] triggerHaptic bridge is unavailable. This is expected in local development."
     );
   }
 }
 
+// src/log-overlay.ts
+var CONSOLE_METHODS = [
+  "debug",
+  "log",
+  "info",
+  "warn",
+  "error"
+];
+var DEFAULT_MAX_ENTRIES = 200;
+var DEFAULT_TITLE = "SDK Logs";
+var OVERLAY_MARGIN = 12;
+var DEFAULT_COLLAPSED_WIDTH = 156;
+var DEFAULT_COLLAPSED_HEIGHT = 52;
+var DEFAULT_EXPANDED_WIDTH = 565;
+var DEFAULT_EXPANDED_HEIGHT = 372;
+var DRAG_THRESHOLD_PX = 6;
+var MIN_EXPANDED_WIDTH = 160;
+var MIN_EXPANDED_HEIGHT = 110;
+var RESIZE_HOTSPOT_PX = 28;
+var TOP_DRAG_ZONE_PX = 44;
+var NOOP_HANDLE = {
+  clear() {
+  },
+  destroy() {
+  },
+  hide() {
+  },
+  isVisible() {
+    return false;
+  },
+  show() {
+  }
+};
+function getBrowserWindow() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function getDocument() {
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  return document;
+}
+function clampMaxEntries(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_MAX_ENTRIES;
+  }
+  return Math.max(10, Math.floor(value));
+}
+function createConsoleSnapshot() {
+  const fallback = console.log.bind(console);
+  return {
+    debug: typeof console.debug === "function" ? console.debug.bind(console) : fallback,
+    log: fallback,
+    info: typeof console.info === "function" ? console.info.bind(console) : fallback,
+    warn: typeof console.warn === "function" ? console.warn.bind(console) : fallback,
+    error: typeof console.error === "function" ? console.error.bind(console) : fallback
+  };
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp);
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const milliseconds = String(date.getMilliseconds()).padStart(3, "0");
+  return "[" + hours + ":" + minutes + ":" + seconds + "." + milliseconds + "]";
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(
+      value,
+      (_key, candidate) => {
+        if (typeof candidate === "bigint") {
+          return candidate.toString() + "n";
+        }
+        if (typeof candidate === "object" && candidate !== null) {
+          if (seen.has(candidate)) {
+            return "[Circular]";
+          }
+          seen.add(candidate);
+        }
+        return candidate;
+      },
+      2
+    ) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatArg(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    if (value.stack) {
+      return value.stack;
+    }
+    return value.name + ": " + value.message;
+  }
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  if (typeof value === "function") {
+    return "[Function " + (value.name || "anonymous") + "]";
+  }
+  return safeStringify(value);
+}
+function formatEntryMessage(args) {
+  const message = args.map(formatArg).join(" ");
+  if (message.length <= 4e3) {
+    return message;
+  }
+  return message.slice(0, 3997) + "...";
+}
+function createEntry(level, args, id) {
+  return {
+    id,
+    level,
+    message: formatEntryMessage(args),
+    timestamp: Date.now()
+  };
+}
+function createButton(label) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.textContent = label;
+  button.style.cssText = [
+    "appearance:none",
+    "border:1px solid rgba(255,255,255,0.18)",
+    "background:rgba(255,255,255,0.06)",
+    "color:#f8fafc",
+    "border-radius:999px",
+    "padding:6px 10px",
+    "font:600 12px/1.1 ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace",
+    "cursor:pointer"
+  ].join(";");
+  return button;
+}
+function getLevelAccent(level) {
+  if (level === "error") {
+    return {
+      lineBackground: "rgba(255, 109, 122, 0.08)"
+    };
+  }
+  if (level === "warn") {
+    return {
+      lineBackground: "rgba(255, 196, 94, 0.07)"
+    };
+  }
+  if (level === "info") {
+    return {
+      lineBackground: "rgba(82, 187, 255, 0.07)"
+    };
+  }
+  if (level === "debug") {
+    return {
+      lineBackground: "rgba(166, 137, 255, 0.07)"
+    };
+  }
+  return {
+    lineBackground: "rgba(117, 235, 191, 0.06)"
+  };
+}
+function getViewportSize() {
+  const browserWindow = getBrowserWindow();
+  return {
+    width: Math.max(320, browserWindow?.innerWidth ?? 1280),
+    height: Math.max(240, browserWindow?.innerHeight ?? 720)
+  };
+}
+function clampPanelSize(size) {
+  const viewport = getViewportSize();
+  const maxWidth = Math.max(MIN_EXPANDED_WIDTH, viewport.width - OVERLAY_MARGIN * 2);
+  const maxHeight = Math.max(
+    MIN_EXPANDED_HEIGHT,
+    viewport.height - OVERLAY_MARGIN * 2
+  );
+  return {
+    width: Math.min(maxWidth, Math.max(MIN_EXPANDED_WIDTH, size.width)),
+    height: Math.min(maxHeight, Math.max(MIN_EXPANDED_HEIGHT, size.height))
+  };
+}
+function getOverlaySize(state) {
+  if (state.expanded && state.panelSize) {
+    return state.panelSize;
+  }
+  const rect = state.ui?.root && typeof state.ui.root.getBoundingClientRect === "function" ? state.ui.root.getBoundingClientRect() : null;
+  if (rect && Number.isFinite(rect.width) && Number.isFinite(rect.height)) {
+    return {
+      width: Math.max(1, rect.width),
+      height: Math.max(1, rect.height)
+    };
+  }
+  return state.expanded ? clampPanelSize({
+    width: DEFAULT_EXPANDED_WIDTH,
+    height: DEFAULT_EXPANDED_HEIGHT
+  }) : { width: DEFAULT_COLLAPSED_WIDTH, height: DEFAULT_COLLAPSED_HEIGHT };
+}
+function applyPanelSize(state) {
+  if (!state.ui) {
+    return;
+  }
+  if (!state.expanded) {
+    state.ui.root.style.width = "auto";
+    state.ui.panel.style.width = "min(565px, calc(100vw - 24px))";
+    state.ui.panel.style.height = "auto";
+    state.ui.entries.style.maxHeight = "min(36vh, 280px)";
+    return;
+  }
+  if (!state.panelSize) {
+    state.ui.root.style.width = "min(565px, calc(100vw - 24px))";
+    state.ui.panel.style.width = "min(565px, calc(100vw - 24px))";
+    state.ui.panel.style.height = "auto";
+    state.ui.entries.style.maxHeight = "min(36vh, 280px)";
+    return;
+  }
+  const nextSize = clampPanelSize(
+    state.panelSize
+  );
+  state.panelSize = nextSize;
+  state.ui.root.style.width = nextSize.width + "px";
+  state.ui.panel.style.width = "100%";
+  state.ui.panel.style.height = nextSize.height + "px";
+  state.ui.entries.style.maxHeight = Math.max(72, nextSize.height - 88) + "px";
+}
+function clampPosition(point, state) {
+  const viewport = getViewportSize();
+  const size = getOverlaySize(state);
+  const maxX = Math.max(OVERLAY_MARGIN, viewport.width - size.width - OVERLAY_MARGIN);
+  const maxY = Math.max(
+    OVERLAY_MARGIN,
+    viewport.height - size.height - OVERLAY_MARGIN
+  );
+  return {
+    x: Math.min(maxX, Math.max(OVERLAY_MARGIN, point.x)),
+    y: Math.min(maxY, Math.max(OVERLAY_MARGIN, point.y))
+  };
+}
+function applyOverlayPosition(state) {
+  if (!state.ui) {
+    return;
+  }
+  if (!state.position) {
+    const viewport = getViewportSize();
+    const size = getOverlaySize(state);
+    state.position = clampPosition(
+      {
+        x: viewport.width - size.width - OVERLAY_MARGIN,
+        y: viewport.height - size.height - OVERLAY_MARGIN
+      },
+      state
+    );
+  } else {
+    state.position = clampPosition(state.position, state);
+  }
+  state.ui.root.style.left = state.position.x + "px";
+  state.ui.root.style.top = state.position.y + "px";
+}
+function getPointFromMouseEvent(event) {
+  return { x: event.clientX, y: event.clientY };
+}
+function getPointFromTouchEvent(event) {
+  const touch = event.touches[0] ?? event.changedTouches[0];
+  if (!touch) {
+    return null;
+  }
+  return { x: touch.clientX, y: touch.clientY };
+}
+function stopDragging(state) {
+  if (state.isDragging || state.isResizing) {
+    state.suppressToggleClickUntil = Date.now() + 180;
+  }
+  state.isDragging = false;
+  state.dragStartPoint = null;
+  state.lastDragPoint = null;
+  state.removeDragListeners?.();
+  state.removeDragListeners = null;
+  if (state.ui) {
+    state.ui.panel.style.cursor = "default";
+    state.ui.dragZone.style.cursor = "grab";
+    state.ui.toggleButton.style.cursor = "grab";
+  }
+}
+function stopResizing(state) {
+  if (state.isResizing) {
+    state.suppressToggleClickUntil = Date.now() + 180;
+  }
+  state.isResizing = false;
+  state.resizeStartPoint = null;
+  state.resizeStartSize = null;
+  state.removeResizeListeners?.();
+  state.removeResizeListeners = null;
+}
+function beginDragTracking(state, startPoint) {
+  const doc = getDocument();
+  if (!doc) {
+    return;
+  }
+  stopResizing(state);
+  stopDragging(state);
+  state.dragMoved = false;
+  state.dragStartPoint = startPoint;
+  state.lastDragPoint = startPoint;
+  const handlePointerMove = (nextPoint) => {
+    if (!state.dragStartPoint || !state.lastDragPoint || !nextPoint) {
+      return;
+    }
+    if (!state.isDragging) {
+      const deltaFromStartX = nextPoint.x - state.dragStartPoint.x;
+      const deltaFromStartY = nextPoint.y - state.dragStartPoint.y;
+      const distance = Math.sqrt(
+        deltaFromStartX * deltaFromStartX + deltaFromStartY * deltaFromStartY
+      );
+      if (distance < DRAG_THRESHOLD_PX) {
+        return;
+      }
+      state.isDragging = true;
+      state.dragMoved = true;
+      if (state.ui) {
+        state.ui.panel.style.cursor = "grabbing";
+        state.ui.dragZone.style.cursor = "grabbing";
+        state.ui.toggleButton.style.cursor = "grabbing";
+      }
+    }
+    const currentPosition = state.position ?? { x: OVERLAY_MARGIN, y: OVERLAY_MARGIN };
+    state.position = clampPosition(
+      {
+        x: currentPosition.x + (nextPoint.x - state.lastDragPoint.x),
+        y: currentPosition.y + (nextPoint.y - state.lastDragPoint.y)
+      },
+      state
+    );
+    state.lastDragPoint = nextPoint;
+    applyOverlayPosition(state);
+  };
+  const handleMouseMove = (event) => {
+    handlePointerMove(getPointFromMouseEvent(event));
+  };
+  const handleTouchMove = (event) => {
+    handlePointerMove(getPointFromTouchEvent(event));
+  };
+  const handleMouseUp = () => {
+    stopDragging(state);
+  };
+  const handleTouchEnd = () => {
+    stopDragging(state);
+  };
+  doc.addEventListener("mousemove", handleMouseMove);
+  doc.addEventListener("mouseup", handleMouseUp);
+  doc.addEventListener("touchmove", handleTouchMove, { passive: true });
+  doc.addEventListener("touchend", handleTouchEnd);
+  doc.addEventListener("touchcancel", handleTouchEnd);
+  state.removeDragListeners = () => {
+    doc.removeEventListener("mousemove", handleMouseMove);
+    doc.removeEventListener("mouseup", handleMouseUp);
+    doc.removeEventListener("touchmove", handleTouchMove);
+    doc.removeEventListener("touchend", handleTouchEnd);
+    doc.removeEventListener("touchcancel", handleTouchEnd);
+  };
+}
+function startResizing(state, startPoint) {
+  const doc = getDocument();
+  if (!doc) {
+    return;
+  }
+  stopDragging(state);
+  stopResizing(state);
+  state.isResizing = true;
+  state.resizeStartPoint = startPoint;
+  state.resizeStartSize = state.panelSize ?? clampPanelSize({ width: DEFAULT_EXPANDED_WIDTH, height: DEFAULT_EXPANDED_HEIGHT });
+  const handleResizeMove = (nextPoint) => {
+    if (!state.isResizing || !state.resizeStartPoint || !state.resizeStartSize || !nextPoint) {
+      return;
+    }
+    state.panelSize = clampPanelSize({
+      width: state.resizeStartSize.width + (nextPoint.x - state.resizeStartPoint.x),
+      height: state.resizeStartSize.height + (nextPoint.y - state.resizeStartPoint.y)
+    });
+    applyPanelSize(state);
+    applyOverlayPosition(state);
+  };
+  const handleMouseMove = (event) => {
+    handleResizeMove(getPointFromMouseEvent(event));
+  };
+  const handleTouchMove = (event) => {
+    handleResizeMove(getPointFromTouchEvent(event));
+  };
+  const handleFinish = () => {
+    stopResizing(state);
+  };
+  doc.addEventListener("mousemove", handleMouseMove);
+  doc.addEventListener("mouseup", handleFinish);
+  doc.addEventListener("touchmove", handleTouchMove, { passive: true });
+  doc.addEventListener("touchend", handleFinish);
+  doc.addEventListener("touchcancel", handleFinish);
+  state.removeResizeListeners = () => {
+    doc.removeEventListener("mousemove", handleMouseMove);
+    doc.removeEventListener("mouseup", handleFinish);
+    doc.removeEventListener("touchmove", handleTouchMove);
+    doc.removeEventListener("touchend", handleFinish);
+    doc.removeEventListener("touchcancel", handleFinish);
+  };
+}
+function isInBottomRightResizeZone(element, point) {
+  const rect = element.getBoundingClientRect();
+  return point.x >= rect.right - RESIZE_HOTSPOT_PX && point.x <= rect.right && point.y >= rect.bottom - RESIZE_HOTSPOT_PX && point.y <= rect.bottom;
+}
+function canStartDragFromTarget(target) {
+  if (!(target instanceof Element)) {
+    return true;
+  }
+  if (target.closest("button") || target.closest("a") || target.closest("input") || target.closest("textarea") || target.closest("select")) {
+    return false;
+  }
+  return true;
+}
+function isInTopDragZone(element, point, zoneHeight) {
+  const rect = element.getBoundingClientRect();
+  return point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.top + zoneHeight;
+}
+function attachDragStartListeners(element, state, options = {}) {
+  element.addEventListener("mousedown", (event) => {
+    if (!options.allowInteractiveTarget && !canStartDragFromTarget(event.target)) {
+      return;
+    }
+    const point = getPointFromMouseEvent(event);
+    if (typeof options.topZoneHeight === "number" && !isInTopDragZone(element, point, options.topZoneHeight)) {
+      return;
+    }
+    beginDragTracking(state, point);
+  });
+  element.addEventListener("touchstart", (event) => {
+    if (!options.allowInteractiveTarget && !canStartDragFromTarget(event.target)) {
+      return;
+    }
+    const point = getPointFromTouchEvent(event);
+    if (!point) {
+      return;
+    }
+    if (typeof options.topZoneHeight === "number" && !isInTopDragZone(element, point, options.topZoneHeight)) {
+      return;
+    }
+    beginDragTracking(state, point);
+  });
+}
+function attachCollapsedToggleListeners(element, state) {
+  const startToggleInteraction = (startPoint) => {
+    const doc = getDocument();
+    if (!doc) {
+      return;
+    }
+    beginDragTracking(state, startPoint);
+    const finishInteraction = () => {
+      releaseListeners();
+      if (state.dragMoved || Date.now() < state.suppressToggleClickUntil) {
+        return;
+      }
+      state.expanded = true;
+      state.unreadCount = 0;
+      renderOverlay(state);
+    };
+    const releaseListeners = () => {
+      doc.removeEventListener("mouseup", finishInteraction);
+      doc.removeEventListener("touchend", finishInteraction);
+      doc.removeEventListener("touchcancel", finishInteraction);
+    };
+    doc.addEventListener("mouseup", finishInteraction);
+    doc.addEventListener("touchend", finishInteraction);
+    doc.addEventListener("touchcancel", finishInteraction);
+  };
+  element.addEventListener("mousedown", (event) => {
+    event.preventDefault();
+    startToggleInteraction(getPointFromMouseEvent(event));
+  });
+  element.addEventListener("touchstart", (event) => {
+    const point = getPointFromTouchEvent(event);
+    if (!point) {
+      return;
+    }
+    event.preventDefault();
+    startToggleInteraction(point);
+  });
+}
+function attachPanelResizeListeners(element, state) {
+  element.addEventListener("mousedown", (event) => {
+    if (!state.expanded || !canStartDragFromTarget(event.target)) {
+      return;
+    }
+    const point = getPointFromMouseEvent(event);
+    if (!isInBottomRightResizeZone(element, point)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    startResizing(state, point);
+  });
+  element.addEventListener("touchstart", (event) => {
+    if (!state.expanded || !canStartDragFromTarget(event.target)) {
+      return;
+    }
+    const point = getPointFromTouchEvent(event);
+    if (!point || !isInBottomRightResizeZone(element, point)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    startResizing(state, point);
+  });
+}
+function createOverlayUi(state) {
+  const root = document.createElement("div");
+  root.style.cssText = [
+    "position:fixed",
+    "left:12px",
+    "top:12px",
+    "z-index:2147483647",
+    "display:flex",
+    "flex-direction:column",
+    "align-items:stretch",
+    "gap:8px",
+    "width:min(565px, calc(100vw - 24px))",
+    "pointer-events:none"
+  ].join(";");
+  const toggleButton = createButton("Logs");
+  toggleButton.style.pointerEvents = "auto";
+  toggleButton.style.alignSelf = "flex-end";
+  toggleButton.style.display = "inline-flex";
+  toggleButton.style.alignItems = "center";
+  toggleButton.style.justifyContent = "center";
+  toggleButton.style.minHeight = "40px";
+  toggleButton.style.minWidth = "76px";
+  toggleButton.style.padding = "8px 14px";
+  toggleButton.style.textAlign = "center";
+  toggleButton.style.border = "1px solid rgba(122, 212, 255, 0.22)";
+  toggleButton.style.background = "linear-gradient(180deg, rgba(13,31,54,0.98), rgba(8,19,37,0.98))";
+  toggleButton.style.boxShadow = "0 18px 40px rgba(4,12,24,0.34)";
+  toggleButton.style.cursor = "grab";
+  toggleButton.style.touchAction = "none";
+  const panel = document.createElement("div");
+  panel.style.cssText = [
+    "position:relative",
+    "display:flex",
+    "flex-direction:column",
+    "width:min(565px, calc(100vw - 24px))",
+    "max-height:min(48vh, 372px)",
+    "border-radius:18px",
+    "border:1px solid rgba(116,167,255,0.16)",
+    "background:linear-gradient(180deg, rgba(9,19,37,0.98), rgba(5,12,24,0.98))",
+    "box-shadow:0 28px 64px rgba(2,8,18,0.46)",
+    "backdrop-filter:blur(16px)",
+    "overflow:hidden",
+    "cursor:default",
+    "pointer-events:auto"
+  ].join(";");
+  const dragZone = document.createElement("div");
+  dragZone.style.cssText = [
+    "position:absolute",
+    "top:0",
+    "left:0",
+    "right:0",
+    "height:" + String(TOP_DRAG_ZONE_PX) + "px",
+    "z-index:1",
+    "cursor:grab",
+    "background:transparent",
+    "pointer-events:auto"
+  ].join(";");
+  const controls = document.createElement("div");
+  controls.style.cssText = [
+    "position:absolute",
+    "top:22px",
+    "right:22px",
+    "z-index:2",
+    "display:flex",
+    "align-items:center",
+    "gap:8px",
+    "pointer-events:auto"
+  ].join(";");
+  const clearButton = createButton("Clear");
+  clearButton.style.background = "rgba(255,255,255,0.1)";
+  clearButton.style.border = "1px solid rgba(255,255,255,0.16)";
+  clearButton.style.color = "#eef6ff";
+  clearButton.style.minHeight = "30px";
+  clearButton.style.padding = "4px 9px";
+  clearButton.style.fontSize = "11px";
+  clearButton.style.backdropFilter = "blur(8px)";
+  const collapseButton = createButton("Hide");
+  collapseButton.style.background = "rgba(113, 171, 255, 0.12)";
+  collapseButton.style.border = "1px solid rgba(113, 171, 255, 0.2)";
+  collapseButton.style.color = "#d9ebff";
+  collapseButton.style.minHeight = "30px";
+  collapseButton.style.padding = "4px 9px";
+  collapseButton.style.fontSize = "11px";
+  collapseButton.style.backdropFilter = "blur(8px)";
+  const body = document.createElement("div");
+  body.style.cssText = [
+    "position:relative",
+    "display:flex",
+    "flex-direction:column",
+    "padding:12px",
+    "background:linear-gradient(180deg, rgba(4,10,20,0.88), rgba(3,8,18,0.98))",
+    "flex:1 1 auto",
+    "min-height:0"
+  ].join(";");
+  const entries = document.createElement("div");
+  entries.style.cssText = [
+    "display:flex",
+    "flex-direction:column",
+    "gap:0",
+    "overflow:auto",
+    "flex:1 1 auto",
+    "min-height:96px",
+    "max-height:min(36vh, 280px)",
+    "padding:0",
+    "border:1px solid rgba(115,153,212,0.14)",
+    "border-radius:12px",
+    "background:rgba(4,10,20,0.82)"
+  ].join(";");
+  const emptyState = document.createElement("div");
+  emptyState.style.cssText = [
+    "display:flex",
+    "align-items:center",
+    "justify-content:center",
+    "flex:1 1 auto",
+    "min-height:96px",
+    "color:rgba(204,222,250,0.6)",
+    "font:500 12px/1.5 ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace",
+    "text-align:center",
+    "padding:18px"
+  ].join(";");
+  emptyState.textContent = "Console output will appear here.";
+  collapseButton.addEventListener("click", (event) => {
+    event.stopPropagation();
+    state.expanded = false;
+    renderOverlay(state);
+  });
+  clearButton.addEventListener("click", (event) => {
+    event.stopPropagation();
+    state.entries = [];
+    state.unreadCount = 0;
+    renderOverlay(state);
+  });
+  controls.appendChild(clearButton);
+  controls.appendChild(collapseButton);
+  entries.appendChild(emptyState);
+  body.appendChild(entries);
+  body.appendChild(controls);
+  panel.appendChild(dragZone);
+  panel.appendChild(body);
+  attachDragStartListeners(dragZone, state);
+  attachPanelResizeListeners(panel, state);
+  attachCollapsedToggleListeners(toggleButton, state);
+  root.appendChild(panel);
+  root.appendChild(toggleButton);
+  return {
+    body,
+    clearButton,
+    collapseButton,
+    controls,
+    dragZone,
+    emptyState,
+    entries,
+    panel,
+    root,
+    toggleButton
+  };
+}
+function renderOverlay(state) {
+  if (!state.ui) {
+    return;
+  }
+  state.ui.panel.style.display = state.expanded ? "flex" : "none";
+  state.ui.toggleButton.style.display = state.expanded ? "none" : "inline-flex";
+  state.ui.toggleButton.textContent = "Logs";
+  if (state.entries.length === 0) {
+    state.ui.entries.style.display = "flex";
+    state.ui.emptyState.style.display = "flex";
+    state.ui.entries.replaceChildren(state.ui.emptyState);
+    applyPanelSize(state);
+    applyOverlayPosition(state);
+    return;
+  }
+  state.ui.entries.style.display = "flex";
+  state.ui.emptyState.style.display = "none";
+  const nextChildren = state.entries.map((entry) => {
+    const accent = getLevelAccent(entry.level);
+    const row = document.createElement("div");
+    row.style.cssText = [
+      "display:flex",
+      "align-items:flex-start",
+      "gap:0",
+      "padding:4px 12px",
+      "background:" + accent.lineBackground
+    ].join(";");
+    const line = document.createElement("div");
+    line.textContent = formatTimestamp(entry.timestamp) + " " + entry.level.toUpperCase() + " " + entry.message;
+    line.style.cssText = [
+      "color:#ecf4ff",
+      "font:500 12px/1.5 ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace",
+      "white-space:pre-wrap",
+      "word-break:break-word",
+      "flex:1 1 auto"
+    ].join(";");
+    row.appendChild(line);
+    return row;
+  });
+  state.ui.entries.replaceChildren(...nextChildren);
+  state.ui.entries.scrollTop = state.ui.entries.scrollHeight;
+  applyPanelSize(state);
+  applyOverlayPosition(state);
+}
+function mountOverlay(state) {
+  const doc = getDocument();
+  if (!doc?.body || state.ui) {
+    return;
+  }
+  state.ui = createOverlayUi(state);
+  doc.body.appendChild(state.ui.root);
+  applyPanelSize(state);
+  applyOverlayPosition(state);
+  renderOverlay(state);
+}
+function enqueueEntry(state, level, args) {
+  state.entries.push(createEntry(level, args, state.nextEntryId));
+  state.nextEntryId += 1;
+  if (state.entries.length > state.maxEntries) {
+    state.entries.splice(0, state.entries.length - state.maxEntries);
+  }
+  if (!state.expanded) {
+    state.unreadCount += 1;
+  }
+  renderOverlay(state);
+}
+function restoreConsole(snapshot) {
+  for (const method of CONSOLE_METHODS) {
+    console[method] = snapshot[method];
+  }
+}
+function patchConsole(state) {
+  for (const method of CONSOLE_METHODS) {
+    const original = state.originalConsole[method];
+    console[method] = (...args) => {
+      enqueueEntry(state, method, args);
+      original(...args);
+    };
+  }
+}
+function cleanupOverlay(browserWindow, state) {
+  restoreConsole(state.originalConsole);
+  stopResizing(state);
+  stopDragging(state);
+  if (state.domReadyHandler) {
+    getDocument()?.removeEventListener("DOMContentLoaded", state.domReadyHandler);
+    state.domReadyHandler = void 0;
+  }
+  if (state.resizeHandler && typeof browserWindow.removeEventListener === "function") {
+    browserWindow.removeEventListener("resize", state.resizeHandler);
+    state.resizeHandler = void 0;
+  }
+  state.ui?.root.remove();
+  state.ui = null;
+  delete browserWindow.__oasizLogOverlayController__;
+  delete browserWindow.__oasizLogOverlayState__;
+}
+function createController(browserWindow, state) {
+  return {
+    retain() {
+      state.refCount += 1;
+      this.ensureMounted();
+    },
+    ensureMounted() {
+      const doc = getDocument();
+      if (!doc) {
+        return;
+      }
+      if (doc.body) {
+        mountOverlay(state);
+        applyOverlayPosition(state);
+        return;
+      }
+      if (!state.domReadyHandler) {
+        state.domReadyHandler = () => {
+          mountOverlay(state);
+          state.domReadyHandler = void 0;
+        };
+        doc.addEventListener("DOMContentLoaded", state.domReadyHandler, {
+          once: true
+        });
+      }
+    },
+    clear() {
+      state.entries = [];
+      state.unreadCount = 0;
+      renderOverlay(state);
+    },
+    show() {
+      state.expanded = true;
+      state.unreadCount = 0;
+      renderOverlay(state);
+    },
+    hide() {
+      state.expanded = false;
+      renderOverlay(state);
+    },
+    isVisible() {
+      return state.expanded;
+    },
+    destroy() {
+      state.refCount = Math.max(0, state.refCount - 1);
+      if (state.refCount === 0) {
+        cleanupOverlay(browserWindow, state);
+      }
+    }
+  };
+}
+function enableLogOverlay(options = {}) {
+  if (options.enabled === false) {
+    return NOOP_HANDLE;
+  }
+  const browserWindow = getBrowserWindow();
+  const doc = getDocument();
+  if (!browserWindow || !doc) {
+    return NOOP_HANDLE;
+  }
+  const existingController = browserWindow.__oasizLogOverlayController__;
+  const existingState = browserWindow.__oasizLogOverlayState__;
+  if (existingController && existingState) {
+    existingController.retain();
+    if (typeof options.maxEntries === "number") {
+      existingState.maxEntries = clampMaxEntries(options.maxEntries);
+      if (existingState.entries.length > existingState.maxEntries) {
+        existingState.entries.splice(
+          0,
+          existingState.entries.length - existingState.maxEntries
+        );
+      }
+    }
+    if (typeof options.collapsed === "boolean") {
+      existingState.expanded = !options.collapsed;
+      applyPanelSize(existingState);
+      if (existingState.expanded) {
+        existingState.unreadCount = 0;
+      }
+    }
+    if (typeof options.title === "string" && options.title.trim().length > 0) {
+      existingState.title = options.title.trim();
+    }
+    existingController.ensureMounted();
+    renderOverlay(existingState);
+    return existingController;
+  }
+  const state = {
+    dragMoved: false,
+    dragStartPoint: null,
+    entries: [],
+    expanded: options.collapsed !== true,
+    isDragging: false,
+    isResizing: false,
+    lastDragPoint: null,
+    maxEntries: clampMaxEntries(options.maxEntries),
+    nextEntryId: 1,
+    originalConsole: createConsoleSnapshot(),
+    panelSize: null,
+    position: null,
+    refCount: 1,
+    removeDragListeners: null,
+    removeResizeListeners: null,
+    resizeStartPoint: null,
+    resizeStartSize: null,
+    suppressToggleClickUntil: 0,
+    title: typeof options.title === "string" && options.title.trim().length > 0 ? options.title.trim() : DEFAULT_TITLE,
+    resizeHandler: void 0,
+    ui: null,
+    unreadCount: 0
+  };
+  const controller = createController(browserWindow, state);
+  browserWindow.__oasizLogOverlayState__ = state;
+  browserWindow.__oasizLogOverlayController__ = controller;
+  patchConsole(state);
+  if (typeof browserWindow.addEventListener === "function") {
+    state.resizeHandler = () => {
+      applyOverlayPosition(state);
+    };
+    browserWindow.addEventListener("resize", state.resizeHandler);
+  }
+  controller.ensureMounted();
+  return controller;
+}
+
 // src/multiplayer.ts
-function isDevelopment2() {
+function isDevelopment3() {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return nodeEnv !== "production";
 }
-function getBridgeWindow2() {
+function getBridgeWindow3() {
   if (typeof window === "undefined") {
     return void 0;
   }
   return window;
 }
-function shareRoomCode(roomCode) {
-  const bridge = getBridgeWindow2();
+function shareRoomCode(roomCode, options) {
+  const bridge = getBridgeWindow3();
   if (typeof bridge?.shareRoomCode === "function") {
-    bridge.shareRoomCode(roomCode);
+    bridge.shareRoomCode(roomCode, options);
     return;
   }
-  if (isDevelopment2()) {
+  if (isDevelopment3()) {
     console.warn(
       "[oasiz/sdk] shareRoomCode bridge is unavailable. This is expected in local development."
     );
   }
 }
+function openInviteModal() {
+  const bridge = getBridgeWindow3();
+  if (typeof bridge?.openInviteModal === "function") {
+    bridge.openInviteModal();
+    return;
+  }
+  if (isDevelopment3()) {
+    console.warn(
+      "[oasiz/sdk] openInviteModal bridge is unavailable. This is expected in local development."
+    );
+  }
+}
 function getGameId() {
-  const bridge = getBridgeWindow2();
+  const bridge = getBridgeWindow3();
   return bridge?.__GAME_ID__;
 }
 function getRoomCode() {
-  const bridge = getBridgeWindow2();
+  const bridge = getBridgeWindow3();
   return bridge?.__ROOM_CODE__;
 }
+function getPlayerId() {
+  const bridge = getBridgeWindow3();
+  return bridge?.__PLAYER_ID__;
+}
 function getPlayerName() {
-  const bridge = getBridgeWindow2();
+  const bridge = getBridgeWindow3();
   return bridge?.__PLAYER_NAME__;
 }
 function getPlayerAvatar() {
-  const bridge = getBridgeWindow2();
+  const bridge = getBridgeWindow3();
   return bridge?.__PLAYER_AVATAR__;
 }
 
 // src/score.ts
-function isDevelopment3() {
+function isDevelopment4() {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return nodeEnv !== "production";
 }
-function warnMissingBridge(methodName) {
-  if (isDevelopment3()) {
+function warnMissingBridge2(methodName) {
+  if (isDevelopment4()) {
     console.warn(
       "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
     );
   }
 }
-function getBridgeWindow3() {
+function getBridgeWindow4() {
   if (typeof window === "undefined") {
     return void 0;
   }
@@ -82,41 +1024,92 @@ function getBridgeWindow3() {
 }
 function submitScore(score) {
   if (!Number.isFinite(score)) {
-    if (isDevelopment3()) {
+    if (isDevelopment4()) {
       console.warn("[oasiz/sdk] submitScore expected a finite number:", score);
     }
     return;
   }
-  const bridge = getBridgeWindow3();
+  const bridge = getBridgeWindow4();
   const normalizedScore = Math.max(0, Math.floor(score));
   if (typeof bridge?.submitScore === "function") {
     bridge.submitScore(normalizedScore);
     return;
   }
-  warnMissingBridge("submitScore");
+  warnMissingBridge2("submitScore");
 }
-function emitScoreConfig(config) {
-  const bridge = getBridgeWindow3();
-  if (typeof bridge?.emitScoreConfig === "function") {
-    bridge.emitScoreConfig(config);
-    return;
+
+// src/score-edit.ts
+function isDevelopment5() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
+function getBridgeWindow5() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function warnMissingBridge3(methodName) {
+  if (isDevelopment5()) {
+    console.warn(
+      "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
+    );
+  }
+}
+async function editScore(payload, methodName) {
+  const bridge = getBridgeWindow5();
+  if (typeof bridge?.__oasizEditScore !== "function") {
+    warnMissingBridge3(methodName);
+    return null;
+  }
+  try {
+    const result = await bridge.__oasizEditScore(payload);
+    return result ?? null;
+  } catch (error) {
+    if (isDevelopment5()) {
+      console.error("[oasiz/sdk] " + methodName + " failed:", error);
+    }
+    return null;
   }
-  warnMissingBridge("emitScoreConfig");
+}
+async function addScore(delta) {
+  if (!Number.isInteger(delta)) {
+    if (isDevelopment5()) {
+      console.warn("[oasiz/sdk] addScore expected an integer:", delta);
+    }
+    return null;
+  }
+  if (delta === 0) {
+    return null;
+  }
+  return editScore({ delta }, "addScore");
+}
+async function setScore(score) {
+  if (!Number.isInteger(score) || score < 0) {
+    if (isDevelopment5()) {
+      console.warn(
+        "[oasiz/sdk] setScore expected a non-negative integer:",
+        score
+      );
+    }
+    return null;
+  }
+  return editScore({ score }, "setScore");
 }
 
 // src/share.ts
-function isDevelopment4() {
+function isDevelopment6() {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return nodeEnv !== "production";
 }
-function getBridgeWindow4() {
+function getBridgeWindow6() {
   if (typeof window === "undefined") {
     return void 0;
   }
   return window;
 }
-function warnMissingBridge2(methodName) {
-  if (isDevelopment4()) {
+function warnMissingBridge4(methodName) {
+  if (isDevelopment6()) {
     console.warn(
       "[oasiz/sdk] " + methodName + " share bridge is unavailable. This is expected in local development."
     );
@@ -151,127 +1144,454 @@ function validateRequest(options) {
       "Share image must be an http(s) URL or a data:image/... base64 string."
     );
   }
-  return {
-    ...hasText ? { text } : {},
-    ...hasScore ? { score: options.score } : {},
-    ...hasImage ? { image: options.image } : {}
-  };
+  return {
+    ...hasText ? { text } : {},
+    ...hasScore ? { score: options.score } : {},
+    ...hasImage ? { image: options.image } : {}
+  };
+}
+async function share(options) {
+  const request = validateRequest(options);
+  const bridge = getBridgeWindow6();
+  if (typeof bridge?.__oasizShareRequest !== "function") {
+    warnMissingBridge4("__oasizShareRequest");
+    throw new Error("Share bridge unavailable");
+  }
+  await bridge.__oasizShareRequest(request);
+}
+
+// src/state.ts
+function isDevelopment7() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
+function getBridgeWindow7() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function warnMissingBridge5(methodName) {
+  if (isDevelopment7()) {
+    console.warn(
+      "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
+    );
+  }
+}
+function loadGameState() {
+  const bridge = getBridgeWindow7();
+  if (typeof bridge?.loadGameState !== "function") {
+    warnMissingBridge5("loadGameState");
+    return {};
+  }
+  const state = bridge.loadGameState();
+  if (!isPlainObject(state)) {
+    if (isDevelopment7()) {
+      console.warn(
+        "[oasiz/sdk] loadGameState returned invalid data. Falling back to empty object."
+      );
+    }
+    return {};
+  }
+  return state;
+}
+function saveGameState(state) {
+  if (!isPlainObject(state)) {
+    if (isDevelopment7()) {
+      console.warn("[oasiz/sdk] saveGameState expected a plain object:", state);
+    }
+    return;
+  }
+  const bridge = getBridgeWindow7();
+  if (typeof bridge?.saveGameState === "function") {
+    bridge.saveGameState(state);
+    return;
+  }
+  warnMissingBridge5("saveGameState");
+}
+function flushGameState() {
+  const bridge = getBridgeWindow7();
+  if (typeof bridge?.flushGameState === "function") {
+    bridge.flushGameState();
+    return;
+  }
+  warnMissingBridge5("flushGameState");
+}
+
+// src/lifecycle.ts
+function isDevelopment8() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
+function addLifecycleListener(eventName, callback) {
+  if (typeof window === "undefined") {
+    if (isDevelopment8()) {
+      console.warn(
+        "[oasiz/sdk] " + eventName + " listener registered without a browser window. This is expected in local development."
+      );
+    }
+    return () => {
+    };
+  }
+  const handler = () => callback();
+  window.addEventListener(eventName, handler);
+  return () => window.removeEventListener(eventName, handler);
+}
+function onPause(callback) {
+  return addLifecycleListener("oasiz:pause", callback);
+}
+function onResume(callback) {
+  return addLifecycleListener("oasiz:resume", callback);
+}
+
+// src/layout.ts
+var INSET_SIDES = ["top", "right", "bottom", "left"];
+var SIDE_TO_AXIS = {
+  top: "vertical",
+  right: "horizontal",
+  bottom: "vertical",
+  left: "horizontal"
+};
+function createInsetEdges(value) {
+  return {
+    top: value,
+    right: value,
+    bottom: value,
+    left: value
+  };
+}
+function isDevelopment9() {
+  const nodeEnv = globalThis.process?.env?.NODE_ENV;
+  return nodeEnv !== "production";
+}
+function getBridgeWindow8() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function warnMissingBridge6(methodName) {
+  if (isDevelopment9()) {
+    console.warn(
+      "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
+    );
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    if (typeof value !== "string") {
+      return void 0;
+    }
+    const parsed = Number.parseFloat(value.trim());
+    if (!Number.isFinite(parsed)) {
+      return void 0;
+    }
+    return parsed;
+  }
+  return value;
+}
+function clampInsetPixels(value) {
+  const numeric = toFiniteNumber(value);
+  if (typeof numeric === "undefined") {
+    return void 0;
+  }
+  return Math.max(0, numeric);
+}
+function normalizeInsetPercent(value) {
+  const numeric = toFiniteNumber(value);
+  if (typeof numeric === "undefined") {
+    return void 0;
+  }
+  return Math.min(100, Math.max(0, numeric));
+}
+function getViewportSize2(bridge, axis) {
+  const visualViewportSize = axis === "vertical" ? bridge.visualViewport?.height : bridge.visualViewport?.width;
+  if (typeof visualViewportSize === "number" && Number.isFinite(visualViewportSize) && visualViewportSize > 0) {
+    return visualViewportSize;
+  }
+  const innerSize = axis === "vertical" ? bridge.innerHeight : bridge.innerWidth;
+  if (typeof innerSize === "number" && Number.isFinite(innerSize) && innerSize > 0) {
+    return innerSize;
+  }
+  const documentSize = axis === "vertical" ? bridge.document?.documentElement?.clientHeight : bridge.document?.documentElement?.clientWidth;
+  if (typeof documentSize === "number" && Number.isFinite(documentSize) && documentSize > 0) {
+    return documentSize;
+  }
+  const bodySize = axis === "vertical" ? bridge.document?.body?.clientHeight : bridge.document?.body?.clientWidth;
+  if (typeof bodySize === "number" && Number.isFinite(bodySize) && bodySize > 0) {
+    return bodySize;
+  }
+  return 0;
+}
+function readCssSafeAreaValue(bridge, cssValue) {
+  const doc = bridge.document;
+  const root = doc?.body ?? doc?.documentElement;
+  if (!doc || !root || typeof doc.createElement !== "function" || typeof root.appendChild !== "function" || typeof bridge.getComputedStyle !== "function") {
+    return 0;
+  }
+  const probe = doc.createElement("div");
+  probe.style.position = "fixed";
+  probe.style.top = "0";
+  probe.style.left = "0";
+  probe.style.width = "0";
+  probe.style.height = "0";
+  probe.style.visibility = "hidden";
+  probe.style.pointerEvents = "none";
+  probe.style.paddingTop = cssValue;
+  root.appendChild(probe);
+  try {
+    return clampInsetPixels(bridge.getComputedStyle(probe).paddingTop) ?? 0;
+  } finally {
+    if (typeof probe.remove === "function") {
+      probe.remove();
+    } else {
+      probe.parentNode?.removeChild(probe);
+    }
+  }
+}
+function readCssSafeAreaPixels(bridge, side) {
+  const envPixels = readCssSafeAreaValue(
+    bridge,
+    "env(safe-area-inset-" + side + ")"
+  );
+  if (envPixels > 0) {
+    return envPixels;
+  }
+  return readCssSafeAreaValue(
+    bridge,
+    "constant(safe-area-inset-" + side + ")"
+  );
+}
+function getDevicePixelRatio(bridge) {
+  const dpr = bridge.devicePixelRatio;
+  if (typeof dpr !== "number" || !Number.isFinite(dpr) || dpr <= 0) {
+    return 1;
+  }
+  return dpr;
+}
+function roughlyEqualPixels(a, b) {
+  return Math.abs(a - b) <= 2;
+}
+function normalizeInsetPixels(value, bridge, side) {
+  const pixels = clampInsetPixels(value);
+  if (typeof pixels === "undefined") {
+    return void 0;
+  }
+  const cssEnvPixels = readCssSafeAreaPixels(bridge, side);
+  if (pixels <= 0) {
+    return cssEnvPixels;
+  }
+  const dpr = getDevicePixelRatio(bridge);
+  if (cssEnvPixels > 0 && dpr > 1 && roughlyEqualPixels(pixels / dpr, cssEnvPixels)) {
+    return cssEnvPixels;
+  }
+  return pixels;
 }
-async function share(options) {
-  const request = validateRequest(options);
-  const bridge = getBridgeWindow4();
-  if (typeof bridge?.__oasizShareRequest !== "function") {
-    warnMissingBridge2("__oasizShareRequest");
-    throw new Error("Share bridge unavailable");
+function pixelsToPercentOfViewport(pixels, bridge, side) {
+  const size = getViewportSize2(bridge, SIDE_TO_AXIS[side]);
+  if (size <= 0) {
+    return 0;
   }
-  await bridge.__oasizShareRequest(request);
+  return normalizeInsetPercent(pixels / size * 100) ?? 0;
 }
-
-// src/state.ts
-function isDevelopment5() {
-  const nodeEnv = globalThis.process?.env?.NODE_ENV;
-  return nodeEnv !== "production";
+function percentToPixelsOfViewport(percent, bridge, side) {
+  const size = getViewportSize2(bridge, SIDE_TO_AXIS[side]);
+  if (size <= 0) {
+    return 0;
+  }
+  return percent / 100 * size;
 }
-function getBridgeWindow5() {
-  if (typeof window === "undefined") {
+function cssSafeAreaPercent(bridge, side) {
+  return pixelsToPercentOfViewport(readCssSafeAreaPixels(bridge, side), bridge, side);
+}
+function resolvePercentValue(value, bridge, side) {
+  const percent = normalizeInsetPercent(value);
+  if (typeof percent === "undefined") {
     return void 0;
   }
-  return window;
+  return percent > 0 ? percent : cssSafeAreaPercent(bridge, side);
 }
-function isPlainObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
+function resolvePixelValue(value, bridge, side) {
+  const numeric = toFiniteNumber(value);
+  if (typeof numeric === "undefined") {
+    return void 0;
   }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
+  return normalizeInsetPixels(numeric, bridge, side);
 }
-function warnMissingBridge3(methodName) {
-  if (isDevelopment5()) {
-    console.warn(
-      "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
-    );
+function sideSuffix(side) {
+  switch (side) {
+    case "top":
+      return "Top";
+    case "right":
+      return "Right";
+    case "bottom":
+      return "Bottom";
+    case "left":
+      return "Left";
   }
 }
-function loadGameState() {
-  const bridge = getBridgeWindow5();
-  if (typeof bridge?.loadGameState !== "function") {
-    warnMissingBridge3("loadGameState");
-    return {};
+function callBridgeFunction(bridge, name) {
+  const fn = bridge[name];
+  if (typeof fn !== "function") {
+    return void 0;
   }
-  const state = bridge.loadGameState();
-  if (!isPlainObject(state)) {
-    if (isDevelopment5()) {
-      console.warn(
-        "[oasiz/sdk] loadGameState returned invalid data. Falling back to empty object."
-      );
-    }
-    return {};
+  try {
+    return fn.call(bridge);
+  } catch (error) {
+    console.error("[oasiz/sdk] " + String(name) + " failed:", error);
+    return void 0;
   }
-  return state;
 }
-function saveGameState(state) {
-  if (!isPlainObject(state)) {
-    if (isDevelopment5()) {
-      console.warn("[oasiz/sdk] saveGameState expected a plain object:", state);
-    }
-    return;
+function readInsetObjectValue(value, side, group) {
+  if (!isRecord(value)) {
+    return void 0;
   }
-  const bridge = getBridgeWindow5();
-  if (typeof bridge?.saveGameState === "function") {
-    bridge.saveGameState(state);
-    return;
+  if (group) {
+    return isRecord(value[group]) ? value[group][side] : void 0;
   }
-  warnMissingBridge3("saveGameState");
+  return value[side];
 }
-function flushGameState() {
-  const bridge = getBridgeWindow5();
-  if (typeof bridge?.flushGameState === "function") {
-    bridge.flushGameState();
-    return;
+function firstDefined(...values) {
+  return values.find((value) => typeof value !== "undefined");
+}
+function readHostInsetSources(bridge) {
+  return {
+    globalPixels: bridge.__OASIZ_VIEWPORT_INSETS__,
+    globalPercent: bridge.__OASIZ_VIEWPORT_INSETS_PERCENT__,
+    methodPixels: callBridgeFunction(bridge, "getViewportInsets"),
+    methodPercent: callBridgeFunction(bridge, "getViewportInsetsPercent")
+  };
+}
+function readIndividualPercentValue(bridge, side) {
+  const suffix = sideSuffix(side);
+  return firstDefined(
+    callBridgeFunction(
+      bridge,
+      "getSafeArea" + suffix + "Percent"
+    ),
+    bridge["__OASIZ_SAFE_AREA_" + side.toUpperCase() + "_PERCENT__"]
+  );
+}
+function readIndividualPixelValue(bridge, side) {
+  const suffix = sideSuffix(side);
+  return firstDefined(
+    callBridgeFunction(
+      bridge,
+      "getSafeArea" + suffix
+    ),
+    bridge["__OASIZ_SAFE_AREA_" + side.toUpperCase() + "__"]
+  );
+}
+function resolveInsetSide(bridge, sources, side) {
+  const percentCandidate = firstDefined(
+    readInsetObjectValue(sources.methodPercent, side, "percent"),
+    readInsetObjectValue(sources.methodPercent, side),
+    readInsetObjectValue(sources.globalPercent, side, "percent"),
+    readInsetObjectValue(sources.globalPercent, side),
+    readInsetObjectValue(sources.methodPixels, side, "percent"),
+    readInsetObjectValue(sources.globalPixels, side, "percent"),
+    readIndividualPercentValue(bridge, side)
+  );
+  const percent = resolvePercentValue(percentCandidate, bridge, side);
+  if (typeof percent !== "undefined") {
+    return {
+      pixels: percentToPixelsOfViewport(percent, bridge, side),
+      percent
+    };
+  }
+  const pixelCandidate = firstDefined(
+    readInsetObjectValue(sources.methodPixels, side, "pixels"),
+    readInsetObjectValue(sources.methodPixels, side),
+    readInsetObjectValue(sources.globalPixels, side, "pixels"),
+    readInsetObjectValue(sources.globalPixels, side),
+    readIndividualPixelValue(bridge, side)
+  );
+  const pixels = resolvePixelValue(pixelCandidate, bridge, side);
+  if (typeof pixels !== "undefined") {
+    return {
+      pixels,
+      percent: pixelsToPercentOfViewport(pixels, bridge, side)
+    };
+  }
+  const cssPixels = readCssSafeAreaPixels(bridge, side);
+  return {
+    pixels: cssPixels,
+    percent: pixelsToPercentOfViewport(cssPixels, bridge, side)
+  };
+}
+function getViewportInsets() {
+  const bridge = getBridgeWindow8();
+  if (!bridge) {
+    return {
+      pixels: createInsetEdges(0),
+      percent: createInsetEdges(0)
+    };
+  }
+  const sources = readHostInsetSources(bridge);
+  const pixels = createInsetEdges(0);
+  const percent = createInsetEdges(0);
+  for (const side of INSET_SIDES) {
+    const resolved = resolveInsetSide(bridge, sources, side);
+    pixels[side] = resolved.pixels;
+    percent[side] = resolved.percent;
   }
-  warnMissingBridge3("flushGameState");
+  return { pixels, percent };
 }
-
-// src/lifecycle.ts
-function isDevelopment6() {
-  const nodeEnv = globalThis.process?.env?.NODE_ENV;
-  return nodeEnv !== "production";
+function getSafeAreaTop() {
+  const bridge = getBridgeWindow8();
+  if (!bridge) {
+    return 0;
+  }
+  const top = getViewportInsets().percent.top;
+  if (top <= 0) {
+    warnMissingBridge6("getSafeAreaTop");
+  }
+  return top;
 }
-function addLifecycleListener(eventName, callback) {
-  if (typeof window === "undefined") {
-    if (isDevelopment6()) {
+function setLeaderboardVisible(visible) {
+  if (typeof visible !== "boolean") {
+    if (isDevelopment9()) {
       console.warn(
-        "[oasiz/sdk] " + eventName + " listener registered without a browser window. This is expected in local development."
+        "[oasiz/sdk] setLeaderboardVisible expected a boolean:",
+        visible
       );
     }
-    return () => {
-    };
+    return;
   }
-  const handler = () => callback();
-  window.addEventListener(eventName, handler);
-  return () => window.removeEventListener(eventName, handler);
-}
-function onPause(callback) {
-  return addLifecycleListener("oasiz:pause", callback);
-}
-function onResume(callback) {
-  return addLifecycleListener("oasiz:resume", callback);
+  const bridge = getBridgeWindow8();
+  if (typeof bridge?.__oasizSetLeaderboardVisible === "function") {
+    bridge.__oasizSetLeaderboardVisible(visible);
+    return;
+  }
+  warnMissingBridge6("__oasizSetLeaderboardVisible");
 }
 
 // src/navigation.ts
+var BACK_BUTTON_TEST_STATE_KEY = "__oasizBackButtonTest";
 var activeBackListeners = 0;
-function isDevelopment7() {
+var activeBackButtonTestingHandle;
+function isDevelopment10() {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return nodeEnv !== "production";
 }
-function getBridgeWindow6() {
+function getBridgeWindow9() {
   if (typeof window === "undefined") {
     return void 0;
   }
   return window;
 }
-function warnMissingBridge4(methodName) {
-  if (isDevelopment7()) {
+function warnMissingBridge7(methodName) {
+  if (isDevelopment10()) {
     console.warn(
       "[oasiz/sdk] " + methodName + " bridge is unavailable. This is expected in local development."
     );
@@ -285,9 +1605,19 @@ function normalizeNavigationError(error) {
     typeof error === "string" ? error : "Back button callback failed."
   );
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function dispatchNavigationEvent(eventName) {
+  const bridge = getBridgeWindow9();
+  if (!bridge || typeof bridge.dispatchEvent !== "function") {
+    return;
+  }
+  bridge.dispatchEvent(new Event(eventName));
+}
 function addNavigationListener(eventName, callback) {
   if (typeof window === "undefined") {
-    if (isDevelopment7()) {
+    if (isDevelopment10()) {
       console.warn(
         "[oasiz/sdk] " + eventName + " listener registered without a browser window. This is expected in local development."
       );
@@ -299,6 +1629,151 @@ function addNavigationListener(eventName, callback) {
   window.addEventListener(eventName, handler);
   return () => window.removeEventListener(eventName, handler);
 }
+function enableBackButtonTesting(options = {}) {
+  activeBackButtonTestingHandle?.destroy();
+  const bridge = getBridgeWindow9();
+  if (!bridge) {
+    if (isDevelopment10()) {
+      console.warn(
+        "[oasiz/sdk] enableBackButtonTesting requires a browser window."
+      );
+    }
+    return {
+      destroy: () => {
+      },
+      isBackOverrideActive: () => false,
+      triggerBack: () => {
+      },
+      triggerLeave: () => {
+      }
+    };
+  }
+  const bridgeWindow = bridge;
+  const keyboard = options.keyboard ?? true;
+  const browserHistory = options.browserHistory ?? true;
+  const log = options.log === true;
+  const previousSetBackOverride = bridgeWindow.__oasizSetBackOverride;
+  const previousLeaveGame = bridgeWindow.__oasizLeaveGame;
+  let destroyed = false;
+  let backOverrideActive = false;
+  let historyTrapArmed = false;
+  function maybeLog(message) {
+    if (log) {
+      console.info("[oasiz/sdk] " + message);
+    }
+  }
+  function canUseHistoryTrap() {
+    return browserHistory && typeof bridgeWindow.history?.pushState === "function" && typeof bridgeWindow.history?.replaceState === "function" && typeof bridgeWindow.location?.href === "string";
+  }
+  function ensureHistoryTrap() {
+    if (!backOverrideActive || historyTrapArmed || !canUseHistoryTrap()) {
+      return;
+    }
+    try {
+      const currentState = isRecord2(bridgeWindow.history.state) ? bridgeWindow.history.state : {};
+      bridgeWindow.history.replaceState(
+        { ...currentState, [BACK_BUTTON_TEST_STATE_KEY]: "base" },
+        "",
+        bridgeWindow.location.href
+      );
+      bridgeWindow.history.pushState(
+        { [BACK_BUTTON_TEST_STATE_KEY]: "trap" },
+        "",
+        bridgeWindow.location.href
+      );
+      historyTrapArmed = true;
+      maybeLog("Local browser Back testing is armed.");
+    } catch (error) {
+      historyTrapArmed = false;
+      if (log) {
+        console.warn("[oasiz/sdk] Failed to arm browser Back testing:", error);
+      }
+    }
+  }
+  function triggerBack() {
+    dispatchNavigationEvent("oasiz:back");
+  }
+  function triggerLeave() {
+    dispatchNavigationEvent("oasiz:leave");
+  }
+  function setBackOverride(active) {
+    backOverrideActive = active;
+    if (active) {
+      ensureHistoryTrap();
+    }
+    if (typeof previousSetBackOverride === "function") {
+      previousSetBackOverride(active);
+    }
+    maybeLog("Back override " + (active ? "enabled" : "disabled") + ".");
+  }
+  function stopBackEvent(event) {
+    event.preventDefault();
+    event.stopPropagation();
+    event.stopImmediatePropagation?.();
+  }
+  const handleKeyDown = (event) => {
+    if (!backOverrideActive || event.key !== "Escape") {
+      return;
+    }
+    stopBackEvent(event);
+    triggerBack();
+  };
+  const handlePopState = (event) => {
+    if (!backOverrideActive) {
+      historyTrapArmed = false;
+      return;
+    }
+    stopBackEvent(event);
+    triggerBack();
+    historyTrapArmed = false;
+    ensureHistoryTrap();
+  };
+  const testLeaveGame = () => {
+    triggerLeave();
+    if (typeof previousLeaveGame === "function") {
+      previousLeaveGame();
+    }
+  };
+  bridgeWindow.__oasizSetBackOverride = setBackOverride;
+  bridgeWindow.__oasizLeaveGame = testLeaveGame;
+  if (keyboard) {
+    bridgeWindow.addEventListener("keydown", handleKeyDown);
+  }
+  if (browserHistory) {
+    bridgeWindow.addEventListener("popstate", handlePopState);
+  }
+  if (activeBackListeners > 0) {
+    setBackOverride(true);
+  }
+  maybeLog("Back button testing bridge installed.");
+  const handle = {
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      if (keyboard) {
+        bridgeWindow.removeEventListener("keydown", handleKeyDown);
+      }
+      if (browserHistory) {
+        bridgeWindow.removeEventListener("popstate", handlePopState);
+      }
+      if (bridgeWindow.__oasizSetBackOverride === setBackOverride) {
+        bridgeWindow.__oasizSetBackOverride = previousSetBackOverride;
+      }
+      if (bridgeWindow.__oasizLeaveGame === testLeaveGame) {
+        bridgeWindow.__oasizLeaveGame = previousLeaveGame;
+      }
+      if (activeBackButtonTestingHandle === handle) {
+        activeBackButtonTestingHandle = void 0;
+      }
+      maybeLog("Back button testing bridge removed.");
+    },
+    isBackOverrideActive: () => backOverrideActive,
+    triggerBack,
+    triggerLeave
+  };
+  activeBackButtonTestingHandle = handle;
+  return handle;
+}
 function onBackButton(callback) {
   const off = addNavigationListener("oasiz:back", () => {
     try {
@@ -308,24 +1783,24 @@ function onBackButton(callback) {
       throw normalizeNavigationError(error);
     }
   });
-  const bridge = getBridgeWindow6();
+  const bridge = getBridgeWindow9();
   activeBackListeners += 1;
   if (activeBackListeners === 1) {
     if (typeof bridge?.__oasizSetBackOverride === "function") {
       bridge.__oasizSetBackOverride(true);
     } else {
-      warnMissingBridge4("__oasizSetBackOverride");
+      warnMissingBridge7("__oasizSetBackOverride");
     }
   }
   return () => {
     off();
     activeBackListeners = Math.max(0, activeBackListeners - 1);
     if (activeBackListeners === 0) {
-      const currentBridge = getBridgeWindow6();
+      const currentBridge = getBridgeWindow9();
       if (typeof currentBridge?.__oasizSetBackOverride === "function") {
         currentBridge.__oasizSetBackOverride(false);
       } else {
-        warnMissingBridge4("__oasizSetBackOverride");
+        warnMissingBridge7("__oasizSetBackOverride");
       }
     }
   };
@@ -334,176 +1809,413 @@ function onLeaveGame(callback) {
   return addNavigationListener("oasiz:leave", callback);
 }
 function leaveGame() {
-  const bridge = getBridgeWindow6();
+  const bridge = getBridgeWindow9();
   if (typeof bridge?.__oasizLeaveGame === "function") {
     bridge.__oasizLeaveGame();
     return;
   }
-  warnMissingBridge4("__oasizLeaveGame");
+  warnMissingBridge7("__oasizLeaveGame");
 }
 
-// src/store.ts
-function isDevelopment8() {
-  const nodeEnv = globalThis.process?.env?.NODE_ENV;
-  return nodeEnv !== "production";
-}
-function getBridgeWindow7() {
+// src/performance.ts
+var DEFAULT_GRAPHICS_PERFORMANCE = {
+  fps: 45,
+  tier: "medium"
+};
+var TIER_DEFAULT_FPS = {
+  minimal: 24,
+  low: 30,
+  medium: 45,
+  high: 60
+};
+var cachedEstimatedGraphicsPerformance;
+function getBridgeWindow10() {
   if (typeof window === "undefined") {
     return void 0;
   }
   return window;
 }
-function warnMissingBridge5(methodName) {
-  if (isDevelopment8()) {
-    console.warn(
-      "[oasiz/sdk] " + methodName + " store bridge is unavailable. This is expected in local development."
-    );
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function toFiniteNumber2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value.trim());
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
   }
+  return void 0;
 }
-async function requestStoreBridge(action, payload) {
-  const bridge = getBridgeWindow7();
-  if (typeof bridge?.__oasizStoreBridgeRequest !== "function") {
-    warnMissingBridge5(action);
-    throw new Error("Store bridge unavailable");
+function clampScore(value) {
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+function clampFps(value) {
+  return Math.min(240, Math.max(1, Math.round(value)));
+}
+function tierFromScore(score) {
+  if (score < 25) return "minimal";
+  if (score < 40) return "low";
+  if (score < 70) return "medium";
+  return "high";
+}
+function tierFromFps(fps) {
+  if (fps < 30) return "minimal";
+  if (fps < 45) return "low";
+  if (fps < 58) return "medium";
+  return "high";
+}
+function fpsFromScore(score) {
+  return TIER_DEFAULT_FPS[tierFromScore(score)];
+}
+function normalizeTier(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  return await bridge.__oasizStoreBridgeRequest({
-    action,
-    payload
-  });
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "minimal" || normalized === "safe") return "minimal";
+  if (normalized === "high") return "high";
+  if (normalized === "medium") return "medium";
+  if (normalized === "low") return "low";
+  return void 0;
 }
-async function getFreshState() {
-  return await requestStoreBridge("getStoreState");
+function firstDefined2(...values) {
+  return values.find((value) => typeof value !== "undefined");
 }
-function subscribeToStoreEvent(eventName, callback) {
-  if (typeof window === "undefined") {
-    return () => {
-    };
+function normalizeMetric(value) {
+  if (typeof value === "undefined" || value === null) {
+    return void 0;
   }
-  const handler = (event) => {
-    const customEvent = event;
-    callback(customEvent.detail);
-  };
-  window.addEventListener(eventName, handler);
-  return () => {
-    window.removeEventListener(eventName, handler);
+  if (typeof value === "number" || typeof value === "string") {
+    const numeric = toFiniteNumber2(value);
+    if (typeof numeric !== "undefined") {
+      const fps2 = clampFps(numeric);
+      return { fps: fps2, tier: tierFromFps(fps2) };
+    }
+    const tier2 = normalizeTier(value);
+    if (tier2) {
+      return { fps: TIER_DEFAULT_FPS[tier2], tier: tier2 };
+    }
+    return void 0;
+  }
+  if (!isRecord3(value)) {
+    return void 0;
+  }
+  const fpsCandidate = firstDefined2(
+    value.fps,
+    value.targetFps,
+    value.frameRate,
+    value.framesPerSecond
+  );
+  const legacyScoreCandidate = firstDefined2(
+    value.score,
+    value.metric,
+    value.value,
+    value.performance,
+    value.performanceScore,
+    value.graphicsScore
+  );
+  const tierCandidate = firstDefined2(
+    value.tier,
+    value.graphicsTier,
+    value.performanceTier,
+    value.qualityTier,
+    value.recommendedTier
+  );
+  const tier = normalizeTier(tierCandidate);
+  const fpsNumeric = toFiniteNumber2(fpsCandidate);
+  const scoreNumeric = toFiniteNumber2(legacyScoreCandidate);
+  if (typeof fpsNumeric === "undefined" && typeof scoreNumeric === "undefined" && !tier) {
+    return void 0;
+  }
+  const fps = clampFps(
+    typeof fpsNumeric !== "undefined" ? fpsNumeric : typeof scoreNumeric !== "undefined" ? fpsFromScore(clampScore(scoreNumeric)) : TIER_DEFAULT_FPS[tier]
+  );
+  return {
+    fps,
+    tier: tier ?? tierFromFps(fps)
   };
 }
-async function syncProducts(products, expectedVersion) {
-  return await requestStoreBridge("syncProducts", {
-    expectedVersion: expectedVersion ?? null,
-    products
-  });
+function callBridgeMetric(bridge, name) {
+  const fn = bridge[name];
+  if (typeof fn !== "function") {
+    return void 0;
+  }
+  try {
+    return fn.call(bridge);
+  } catch (error) {
+    console.error("[oasiz/sdk] " + String(name) + " failed:", error);
+    return void 0;
+  }
 }
-async function getProducts() {
-  const state = await getFreshState();
-  return state.products;
+function readHostGraphicsPerformance(bridge) {
+  const candidates = [
+    callBridgeMetric(bridge, "getGraphicsPerformance"),
+    callBridgeMetric(bridge, "getGraphicsPerformanceMetric"),
+    callBridgeMetric(bridge, "getPerformanceMetric"),
+    bridge.__OASIZ_GRAPHICS_PERFORMANCE__,
+    bridge.__OASIZ_PERFORMANCE_METRIC__
+  ];
+  for (const candidate of candidates) {
+    const metric = normalizeMetric(candidate);
+    if (metric) {
+      return metric;
+    }
+  }
+  return void 0;
 }
-async function getEntitlements() {
-  const state = await getFreshState();
-  return state.entitlements;
+function getDevicePixelRatio2(bridge) {
+  const dpr = bridge.devicePixelRatio;
+  return typeof dpr === "number" && Number.isFinite(dpr) && dpr > 0 ? dpr : 1;
 }
-async function hasEntitlement(productId) {
-  const state = await getFreshState();
-  return state.entitlements.find((item) => item.productId === productId)?.owned === true;
+function getNavigatorValue(bridge) {
+  return bridge.navigator;
 }
-async function getQuantity(productId) {
-  const state = await getFreshState();
-  return state.entitlements.find((item) => item.productId === productId)?.quantity ?? 0;
+function parseIosMajorVersion(userAgent) {
+  const match = /\bOS (\d+)_/i.exec(userAgent);
+  if (!match) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(match[1] ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
 }
-async function purchase(productId, quantity = 1) {
-  return await requestStoreBridge("purchaseProduct", {
-    productId,
-    quantity
-  });
+function isAppleMobileDevice(bridge) {
+  const userAgent = bridge.navigator?.userAgent ?? "";
+  return /iP(hone|ad|od)/i.test(userAgent) || /Macintosh/i.test(userAgent) && (bridge.navigator?.maxTouchPoints ?? 0) > 1;
 }
-async function consume(productId, quantity = 1) {
-  return await requestStoreBridge("consumeProduct", {
-    productId,
-    quantity
-  });
+function getLongestScreenEdge(bridge) {
+  const screenWidth = bridge.screen?.width;
+  const screenHeight = bridge.screen?.height;
+  const innerWidth = bridge.innerWidth;
+  const innerHeight = bridge.innerHeight;
+  return Math.max(
+    typeof screenWidth === "number" ? screenWidth : 0,
+    typeof screenHeight === "number" ? screenHeight : 0,
+    typeof innerWidth === "number" ? innerWidth : 0,
+    typeof innerHeight === "number" ? innerHeight : 0
+  );
 }
-async function getJemBalance() {
-  const state = await getFreshState();
-  return state.jemBalance;
+function isCoarsePointer(bridge) {
+  try {
+    return bridge.matchMedia?.("(pointer: coarse)").matches === true;
+  } catch {
+    return false;
+  }
 }
-function onEntitlementsChanged(callback) {
-  return subscribeToStoreEvent("oasiz:entitlements-changed", (state) => {
-    callback(state.entitlements);
-  });
+function getWebGlInfo(bridge) {
+  const canvas = bridge.document?.createElement?.("canvas");
+  if (!canvas || typeof canvas.getContext !== "function") {
+    return { webglVersion: 0 };
+  }
+  const gl2 = canvas.getContext("webgl2");
+  const gl = gl2 ?? canvas.getContext("webgl") ?? canvas.getContext("experimental-webgl");
+  if (!gl) {
+    return { webglVersion: 0 };
+  }
+  const context = gl;
+  let maxTextureSize;
+  let renderer;
+  try {
+    const value = context.getParameter(context.MAX_TEXTURE_SIZE);
+    if (typeof value === "number" && Number.isFinite(value)) {
+      maxTextureSize = value;
+    }
+  } catch {
+  }
+  try {
+    const debugInfo = context.getExtension("WEBGL_debug_renderer_info");
+    const rendererParam = debugInfo?.UNMASKED_RENDERER_WEBGL ?? context.RENDERER;
+    const value = context.getParameter(rendererParam);
+    if (typeof value === "string") {
+      renderer = value;
+    }
+  } catch {
+  }
+  return {
+    maxTextureSize,
+    renderer,
+    webglVersion: gl2 ? 2 : 1
+  };
 }
-function onJemBalanceChanged(callback) {
-  return subscribeToStoreEvent("oasiz:jem-balance-changed", (state) => {
-    callback(state.jemBalance);
-  });
+function applyMemoryScore(score, memory) {
+  if (typeof memory !== "number" || !Number.isFinite(memory) || memory <= 0) {
+    return score;
+  }
+  if (memory <= 1) return score - 18;
+  if (memory <= 2) return score - 10;
+  if (memory >= 8) return score + 16;
+  if (memory >= 6) return score + 10;
+  return score;
+}
+function applyCoreScore(score, cores) {
+  if (typeof cores !== "number" || !Number.isFinite(cores) || cores <= 0) {
+    return score;
+  }
+  if (cores <= 2) return score - 12;
+  if (cores <= 4) return score;
+  if (cores >= 8) return score + 12;
+  return score + 8;
+}
+function applyWebGlScore(score, info) {
+  let next = score;
+  if (info.webglVersion === 2) {
+    next += 16;
+  } else if (info.webglVersion === 1) {
+    next += 6;
+  } else {
+    next -= 25;
+  }
+  if (typeof info.maxTextureSize === "number") {
+    if (info.maxTextureSize >= 8192) next += 10;
+    else if (info.maxTextureSize >= 4096) next += 3;
+    else next -= 8;
+  }
+  const renderer = info.renderer?.toLowerCase() ?? "";
+  if (/swiftshader|llvmpipe|software/.test(renderer)) {
+    next = Math.min(next, 35);
+  } else if (/\bm[1-9]\b|apple gpu|a1[6-9]|rtx|radeon|adreno 7|adreno 8/.test(renderer)) {
+    next += 8;
+  }
+  return next;
+}
+function applyMobileCostScore(score, bridge) {
+  if (!isCoarsePointer(bridge)) {
+    return score;
+  }
+  const dpr = getDevicePixelRatio2(bridge);
+  const width = bridge.screen?.width ?? bridge.innerWidth ?? 0;
+  const height = bridge.screen?.height ?? bridge.innerHeight ?? 0;
+  const physicalPixels = width * height * dpr * dpr;
+  if (physicalPixels > 4e6) {
+    return score - 5;
+  }
+  return score;
+}
+function applyAppleMobileRules(score, bridge) {
+  if (!isAppleMobileDevice(bridge)) {
+    return score;
+  }
+  const userAgent = bridge.navigator?.userAgent ?? "";
+  const iosMajorVersion = parseIosMajorVersion(userAgent);
+  const highDensityDisplay = getDevicePixelRatio2(bridge) >= 3;
+  const longestScreenEdge = getLongestScreenEdge(bridge);
+  if (typeof iosMajorVersion === "number" && iosMajorVersion < 15) {
+    return Math.min(score, 35);
+  }
+  if (highDensityDisplay && longestScreenEdge >= 430 && (typeof iosMajorVersion === "undefined" || iosMajorVersion >= 17)) {
+    return Math.max(score, 78);
+  }
+  if (highDensityDisplay && longestScreenEdge >= 414 && (typeof iosMajorVersion === "undefined" || iosMajorVersion >= 16)) {
+    return Math.max(score, 62);
+  }
+  return Math.min(score, 48);
+}
+function estimateGraphicsPerformance(bridge) {
+  const navigatorValue = getNavigatorValue(bridge);
+  let score = 45;
+  score = applyMemoryScore(score, navigatorValue?.deviceMemory);
+  score = applyCoreScore(score, navigatorValue?.hardwareConcurrency);
+  score = applyWebGlScore(score, getWebGlInfo(bridge));
+  score = applyMobileCostScore(score, bridge);
+  score = applyAppleMobileRules(score, bridge);
+  const normalizedScore = clampScore(score);
+  return {
+    fps: fpsFromScore(normalizedScore),
+    tier: tierFromScore(normalizedScore)
+  };
+}
+function getGraphicsPerformance() {
+  const bridge = getBridgeWindow10();
+  if (!bridge) {
+    return { ...DEFAULT_GRAPHICS_PERFORMANCE };
+  }
+  const hostMetric = readHostGraphicsPerformance(bridge);
+  if (hostMetric) {
+    return hostMetric;
+  }
+  cachedEstimatedGraphicsPerformance ??= estimateGraphicsPerformance(bridge);
+  return { ...cachedEstimatedGraphicsPerformance };
 }
 
 // src/index.ts
 var oasiz = {
   submitScore,
-  emitScoreConfig,
+  addScore,
+  setScore,
+  getPlayerCharacter,
   share,
   triggerHaptic,
+  enableLogOverlay,
   loadGameState,
   saveGameState,
   flushGameState,
   shareRoomCode,
+  openInviteModal,
   onPause,
   onResume,
+  getSafeAreaTop,
+  getViewportInsets,
+  setLeaderboardVisible,
+  getGraphicsPerformance,
+  enableBackButtonTesting,
   onBackButton,
   onLeaveGame,
   leaveGame,
-  store: {
-    syncProducts,
-    getProducts,
-    getEntitlements,
-    hasEntitlement,
-    getQuantity,
-    purchase,
-    consume,
-    getJemBalance,
-    onEntitlementsChanged,
-    onJemBalanceChanged
-  },
   get gameId() {
     return getGameId();
   },
   get roomCode() {
     return getRoomCode();
   },
+  get playerId() {
+    return getPlayerId();
+  },
   get playerName() {
     return getPlayerName();
   },
   get playerAvatar() {
     return getPlayerAvatar();
+  },
+  get safeAreaTop() {
+    return getSafeAreaTop();
+  },
+  get viewportInsets() {
+    return getViewportInsets();
+  },
+  get graphicsPerformance() {
+    return getGraphicsPerformance();
   }
 };
 export {
-  consume,
-  emitScoreConfig,
+  addScore,
+  enableBackButtonTesting,
+  enableLogOverlay,
   flushGameState,
-  getEntitlements,
   getGameId,
-  getJemBalance,
+  getGraphicsPerformance,
   getPlayerAvatar,
+  getPlayerCharacter,
+  getPlayerId,
   getPlayerName,
-  getProducts,
-  getQuantity,
   getRoomCode,
-  hasEntitlement,
+  getSafeAreaTop,
+  getViewportInsets,
   leaveGame,
   loadGameState,
   oasiz,
   onBackButton,
-  onEntitlementsChanged,
-  onJemBalanceChanged,
   onLeaveGame,
   onPause,
   onResume,
-  purchase,
+  openInviteModal,
   saveGameState,
+  setLeaderboardVisible,
+  setScore,
   share,
   shareRoomCode,
   submitScore,
-  syncProducts,
   triggerHaptic
 };