@react-three/fiber 10.0.0-canary.f81281f → 10.0.0-canary.fbc659b

package/dist/shared/fiber.D4fD6H74.d.mts

@@ -0,0 +1,48 @@
+import { aO as FrameNextCallback } from './fiber.C_MFx7We.mjs';
+import { UseFrameNextOptions, FrameNextControls } from '@pmndrs/scheduler';
+
+/**
+ * Frame hook with phase-based ordering, priority, and FPS throttling.
+ *
+ * Always delivers full RootState — works both inside and outside Canvas context:
+ * - Inside Canvas: Full RootState (renderer, scene, camera, etc.)
+ * - Outside Canvas: The job registers immediately but the callback is held until a
+ *   Canvas adopts it, then runs with full RootState. For hostless / standalone
+ *   frame loops with no Canvas, use `@pmndrs/scheduler` directly.
+ *
+ * Returns a controls object for manual stepping, pausing, and resuming.
+ *
+ * @param callback - Function called each frame with (state, delta). Optional if you only need scheduler access.
+ * @param priorityOrOptions - Either a priority number (backwards compat) or options object
+ * @returns Controls object with step(), stepAll(), invalidate(), pause(), resume(), isPaused, id, rootId, scheduler
+ *
+ * @example
+ * // Simple priority (backwards compat)
+ * useFrame((state, delta) => { ... }, 5)
+ *
+ * @example
+ * // With phase-based ordering
+ * useFrame((state, delta) => { ... }, { phase: 'physics' })
+ *
+ * @example
+ * // Outside Canvas - callback waits for a Canvas, then always has full state
+ * function UI() {
+ *   useFrame((state, delta) => { syncUI(state.camera) });
+ *   return <button>...</button>;
+ * }
+ *
+ * @example
+ * // Hostless / standalone loop (no Canvas) - use @pmndrs/scheduler directly
+ * import { getScheduler } from '@pmndrs/scheduler'
+ * getScheduler().register((state, delta) => { updateGame(delta) })
+ *
+ * @example
+ * // Scheduler-only access (no callback)
+ * const { scheduler } = useFrame()
+ * scheduler.pauseJob('some-job-id')
+ *
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
+ */
+declare function useFrame(callback?: FrameNextCallback, priorityOrOptions?: number | UseFrameNextOptions): FrameNextControls;
+
+export { useFrame as u };

package/dist/shared/{fiber.B6zNSmwj.cjs → fiber.DfiCufha.cjs}

@@ -28,16 +28,18 @@ function useMutableCallback(fn) {
   useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]);
   return ref;
 }
+const useActivityBridge = React__namespace["Activity"] ? itsFine.useActivityBridge : () => React__namespace.Fragment;
 function useBridge() {
   const fiber = itsFine.useFiber();
   const ContextBridge = itsFine.useContextBridge();
+  const ActivityBridge = useActivityBridge();
   return React__namespace.useMemo(
     () => ({ children }) => {
       const strict = !!itsFine.traverseFiber(fiber, true, (node) => node.type === React__namespace.StrictMode);
       const Root = strict ? React__namespace.StrictMode : React__namespace.Fragment;
-      return /* @__PURE__ */ jsxRuntime.jsx(Root, { children: /* @__PURE__ */ jsxRuntime.jsx(ContextBridge, { children }) });
+      return /* @__PURE__ */ jsxRuntime.jsx(Root, { children: /* @__PURE__ */ jsxRuntime.jsx(ActivityBridge, { children: /* @__PURE__ */ jsxRuntime.jsx(ContextBridge, { children }) }) });
     },
-    [fiber, ContextBridge]
+    [fiber, ContextBridge, ActivityBridge]
   );
 }
 function Block({ set }) {
@@ -62,6 +64,23 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
     }
   }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
 })();
+const noop = () => {
+};
+function Gate({ promise, onSettled }) {
+  React__namespace.use(promise);
+  useIsomorphicLayoutEffect(onSettled, [onSettled]);
+  return null;
+}
+function useGate() {
+  const [promise, setPromise] = React__namespace.useState(null);
+  const onSettled = React__namespace.useCallback(() => setPromise(null), []);
+  const waitFor = React__namespace.useCallback(
+    (next) => setPromise((current) => current ?? Promise.resolve(next).then(noop, noop)),
+    []
+  );
+  const gate = promise ? /* @__PURE__ */ jsxRuntime.jsx(React__namespace.Suspense, { fallback: null, children: /* @__PURE__ */ jsxRuntime.jsx(Gate, { promise, onSettled }) }) : null;
+  return [gate, waitFor];
+}
 
 const shownNotices = /* @__PURE__ */ new Set();
 function notifyDepreciated({ heading, body, link }) {
@@ -119,10 +138,160 @@ function notifyAlpha({ message, link }) {
     console.log(`%cMore info: ${link}`, "color: #6366f1; font-weight: normal;");
   }
 }
+function isDevelopment() {
+  try {
+    return process.env.NODE_ENV !== "production";
+  } catch {
+    return true;
+  }
+}
+
+const INTERNAL_LIB_MARKERS = [
+  "zustand",
+  "setState",
+  "Object.assign",
+  "@pmndrs/scheduler",
+  "Scheduler.tickRoot",
+  "Scheduler.stepJob"
+];
+function isInternalRendererAccess(stack, callerDepth = 2) {
+  if (!stack) return false;
+  const caller = stack.split("\n")[callerDepth] ?? "";
+  return INTERNAL_LIB_MARKERS.some((m) => caller.includes(m));
+}
+
+const isAccessorDescriptor = (descriptor) => !!descriptor && (descriptor.get !== void 0 || descriptor.set !== void 0);
+const isAccessor = (object, key) => isAccessorDescriptor(Object.getOwnPropertyDescriptor(object, key));
+function cloneState(...sources) {
+  const target = {};
+  for (const source of sources) {
+    if (source) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  }
+  return target;
+}
+function preserveAccessors(rawSet, get) {
+  return ((partial, replace) => {
+    const previous = get();
+    const patch = typeof partial === "function" ? partial(previous) : partial;
+    if (replace || !previous || patch == null || Object.is(patch, previous)) {
+      return rawSet(patch, replace);
+    }
+    const next = cloneState(previous);
+    const viaSetter = [];
+    for (const key of Reflect.ownKeys(patch)) {
+      const descriptor = Object.getOwnPropertyDescriptor(patch, key);
+      if (!descriptor.enumerable) continue;
+      if (isAccessorDescriptor(descriptor)) {
+        Object.defineProperty(next, key, descriptor);
+      } else if (isAccessor(next, key)) {
+        viaSetter.push(key);
+      } else {
+        Object.defineProperty(next, key, {
+          value: descriptor.value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    for (const key of viaSetter) next[key] = patch[key];
+    rawSet(next, true);
+  });
+}
+const keepAccessors = (initializer) => (rawSet, get, api) => {
+  const set = preserveAccessors(rawSet, get);
+  api.setState = set;
+  return initializer(set, get, api);
+};
+let glNoticeShown = false;
+function defineRendererAccessors(state) {
+  Object.defineProperty(state, "gl", {
+    get() {
+      const renderer = this.internal?.actualRenderer;
+      if (!glNoticeShown && renderer && !this.isLegacy) {
+        const stack = new Error().stack || "";
+        if (!isInternalRendererAccess(stack)) {
+          glNoticeShown = true;
+          const cleanedStack = stack.split("\n").slice(2).join("\n") || "Stack trace unavailable";
+          notifyDepreciated({
+            heading: "Accessing state.gl in WebGPU mode",
+            body: "Please use state.renderer instead. state.gl is deprecated and will be removed in future versions.\n\nFor backwards compatibility, state.gl currently maps to state.renderer, but this may cause issues with libraries expecting WebGLRenderer.\n\nAccessed from:\n" + cleanedStack
+          });
+        }
+      }
+      return renderer;
+    },
+    set(value) {
+      this.internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(state, "renderer", {
+    get() {
+      return this.internal?.actualRenderer;
+    },
+    set(value) {
+      this.internal.actualRenderer = value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
 
 const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
 const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React__namespace.createContext(null));
 
+const R3F_EXTENSIONS = Symbol.for("@react-three/fiber.extensions");
+function getRegistry() {
+  return globalThis[R3F_EXTENSIONS] ?? (globalThis[R3F_EXTENSIONS] = {
+    extensions: /* @__PURE__ */ new Map(),
+    roots: /* @__PURE__ */ new Set(),
+    applied: /* @__PURE__ */ new WeakMap()
+  });
+}
+function setupRoot(registry, store, extension) {
+  let applied = registry.applied.get(store);
+  if (!applied) registry.applied.set(store, applied = /* @__PURE__ */ new Map());
+  if (applied.has(extension.name)) return;
+  applied.set(extension.name, extension);
+  const patch = extension.setup?.(store);
+  if (patch) store.setState(patch);
+}
+function registerRootExtension(extension) {
+  const registry = getRegistry();
+  registry.extensions.set(extension.name, extension);
+  for (const store of registry.roots) setupRoot(registry, store, extension);
+  return () => {
+    if (registry.extensions.get(extension.name) === extension) registry.extensions.delete(extension.name);
+  };
+}
+function setRenderOverride(store, render) {
+  store.getState().internal.renderOverride = render;
+}
+function attachRootExtensions(store) {
+  const registry = getRegistry();
+  registry.roots.add(store);
+  for (const extension of registry.extensions.values()) setupRoot(registry, store, extension);
+}
+function current(registry, setUpBy) {
+  return registry.extensions.get(setUpBy.name) ?? setUpBy;
+}
+function detachRootExtensions(store) {
+  const registry = getRegistry();
+  if (!registry.roots.delete(store)) return;
+  const applied = registry.applied.get(store);
+  registry.applied.delete(store);
+  if (!applied) return;
+  for (const setUpBy of applied.values()) current(registry, setUpBy).dispose?.(store);
+}
+function notifyRootExtensionsHmr(store) {
+  const registry = getRegistry();
+  const applied = registry.applied.get(store);
+  if (!applied) return;
+  for (const setUpBy of applied.values()) current(registry, setUpBy).hmr?.(store);
+}
+
 function useStore() {
   const store = React.useContext(context);
   if (!store) throw new Error("R3F: Hooks can only be used within the Canvas component!");
@@ -149,12 +318,20 @@ function useFrame(callback, priorityOrOptions) {
   const options = React__namespace.useMemo(() => {
     return typeof priorityOrOptions === "number" ? { priority: priorityOrOptions } : priorityOrOptions ?? {};
   }, [optionsKey]);
-  const reactId = React__namespace.useId();
-  const id = options.id ?? reactId;
+  const [generatedId] = React__namespace.useState(() => scheduler$1.generateJobId());
+  const id = options.id ?? generatedId;
   const callbackRef = useMutableCallback(callback);
   const isLegacyPriority = typeof priorityOrOptions === "number" && priorityOrOptions > 0;
+  const isLegacyOrdering = typeof priorityOrOptions === "number" && priorityOrOptions < 0;
   useIsomorphicLayoutEffect(() => {
     if (!callback) return;
+    if (isLegacyOrdering) {
+      notifyDepreciated({
+        heading: "useFrame numeric priority order is reversed in v10",
+        body: "useFrame(callback, number) is deprecated and its ordering direction is reversed from v9: v9 ran lower numbers first, v10 maps the number to { priority } and runs higher numbers first, so a negative priority now runs after default-priority jobs.\n\nUse { before, after } to name the dependency, or { priority } with the v10 direction (higher = earlier).",
+        link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
+      });
+    }
     if (isInsideCanvas) {
       const state = store.getState();
       const rootId = state.internal.rootId;
@@ -168,19 +345,17 @@ function useFrame(callback, priorityOrOptions) {
         }
         notifyDepreciated({
           heading: "useFrame with numeric priority is deprecated",
-          body: 'Using useFrame(callback, number) to control render order is deprecated.\n\nFor custom rendering, use: useFrame(callback, { phase: "render" })\nFor execution order within update phase, use: useFrame(callback, { priority: number })',
+          body: 'Using useFrame(callback, number) to control render order is deprecated.\n\nFor custom rendering, use: useFrame(callback, { phase: "render" })\nFor execution order within a phase, use: useFrame(callback, { priority: number }) \u2014 higher runs first, the reverse of v9',
           link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
         });
       }
       const wrappedCallback = (frameState, delta) => {
-        const localState = store.getState();
-        const mergedState = {
-          ...localState,
-          time: frameState.time,
-          delta: frameState.delta,
-          elapsed: frameState.elapsed,
-          frame: frameState.frame
-        };
+        const mergedState = cloneState(store.getState());
+        mergedState.time = frameState.time;
+        mergedState.delta = frameState.delta;
+        mergedState.elapsed = frameState.elapsed;
+        mergedState.frame = frameState.frame;
+        mergedState.overstep = frameState.overstep;
         callbackRef.current?.(mergedState, delta);
       };
       const unregister = scheduler$1.register(wrappedCallback, {
@@ -213,7 +388,7 @@ function useFrame(callback, priorityOrOptions) {
         { id, ...options }
       );
     }
-  }, [store, scheduler$1, id, optionsKey, isLegacyPriority, isInsideCanvas]);
+  }, [store, scheduler$1, id, optionsKey, isLegacyPriority, isLegacyOrdering, isInsideCanvas]);
   const isPaused = React__namespace.useSyncExternalStore(
     // Subscribe function
     React__namespace.useCallback(
@@ -291,68 +466,55 @@ function useFrame(callback, priorityOrOptions) {
   return controls;
 }
 
-const R3F_EXTENSIONS = Symbol.for("@react-three/fiber.extensions");
-function getRegistry() {
-  return globalThis[R3F_EXTENSIONS] ?? (globalThis[R3F_EXTENSIONS] = {
-    extensions: /* @__PURE__ */ new Map(),
-    roots: /* @__PURE__ */ new Set(),
-    applied: /* @__PURE__ */ new WeakMap()
-  });
-}
-function setupRoot(registry, store, extension) {
-  let applied = registry.applied.get(store);
-  if (!applied) registry.applied.set(store, applied = /* @__PURE__ */ new Map());
-  if (applied.has(extension.name)) return;
-  applied.set(extension.name, extension);
-  const patch = extension.setup?.(store);
-  if (patch) store.setState(patch);
-}
-function registerRootExtension(extension) {
-  const registry = getRegistry();
-  registry.extensions.set(extension.name, extension);
-  for (const store of registry.roots) setupRoot(registry, store, extension);
-  return () => {
-    if (registry.extensions.get(extension.name) === extension) registry.extensions.delete(extension.name);
-  };
-}
-function setRenderOverride(store, render) {
-  store.getState().internal.renderOverride = render;
-}
-function attachRootExtensions(store) {
-  const registry = getRegistry();
-  registry.roots.add(store);
-  for (const extension of registry.extensions.values()) setupRoot(registry, store, extension);
-}
-function current(registry, setUpBy) {
-  return registry.extensions.get(setUpBy.name) ?? setUpBy;
+const R3F_STAGED_TEXTURES = Symbol.for("@react-three/fiber.stagedTextures");
+const globalStaging = globalThis;
+const staging = globalStaging[R3F_STAGED_TEXTURES] ?? (globalStaging[R3F_STAGED_TEXTURES] = /* @__PURE__ */ new WeakMap());
+function stageTextures(store, entries) {
+  const registered = store.getState().textures;
+  let staged = staging.get(store);
+  for (const [url, texture] of entries) {
+    if (registered.has(url)) continue;
+    if (!staged) staging.set(store, staged = /* @__PURE__ */ new Map());
+    staged.set(url, texture);
+  }
 }
-function detachRootExtensions(store) {
-  const registry = getRegistry();
-  if (!registry.roots.delete(store)) return;
-  const applied = registry.applied.get(store);
-  registry.applied.delete(store);
-  if (!applied) return;
-  for (const setUpBy of applied.values()) current(registry, setUpBy).dispose?.(store);
+function unstageTextures(store, urls) {
+  const staged = staging.get(store);
+  if (!staged) return;
+  for (const url of urls) staged.delete(url);
+  if (staged.size === 0) staging.delete(store);
 }
-function notifyRootExtensionsHmr(store) {
-  const registry = getRegistry();
-  const applied = registry.applied.get(store);
-  if (!applied) return;
-  for (const setUpBy of applied.values()) current(registry, setUpBy).hmr?.(store);
+function getTextureView(store) {
+  const registered = store.getState().textures;
+  const staged = staging.get(store);
+  if (!staged) return registered;
+  const view = new Map(registered);
+  for (const [url, texture] of staged) if (!view.has(url)) view.set(url, texture);
+  return view;
 }
 
 exports.Block = Block;
 exports.ErrorBoundary = ErrorBoundary;
 exports.attachRootExtensions = attachRootExtensions;
+exports.cloneState = cloneState;
 exports.context = context;
+exports.defineRendererAccessors = defineRendererAccessors;
 exports.detachRootExtensions = detachRootExtensions;
+exports.getTextureView = getTextureView;
+exports.isAccessor = isAccessor;
+exports.isDevelopment = isDevelopment;
+exports.keepAccessors = keepAccessors;
 exports.notifyAlpha = notifyAlpha;
 exports.notifyDepreciated = notifyDepreciated;
 exports.notifyRootExtensionsHmr = notifyRootExtensionsHmr;
+exports.preserveAccessors = preserveAccessors;
 exports.registerRootExtension = registerRootExtension;
 exports.setRenderOverride = setRenderOverride;
+exports.stageTextures = stageTextures;
+exports.unstageTextures = unstageTextures;
 exports.useBridge = useBridge;
 exports.useFrame = useFrame;
+exports.useGate = useGate;
 exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;
 exports.useMutableCallback = useMutableCallback;
 exports.useStore = useStore;