@react-three/fiber 10.0.0-canary.dc0ec15 → 10.0.0-canary.de17310

package/dist/webgpu/index.cjs

@@ -15,9 +15,6 @@ const EXRLoader_js = require('three/examples/jsm/loaders/EXRLoader.js');
 const UltraHDRLoader_js = require('three/examples/jsm/loaders/UltraHDRLoader.js');
 const gainmapJs = require('@monogrid/gainmap-js');
 const suspendReact = require('suspend-react');
-const lite = require('dequal/lite');
-require('zustand/shallow');
-const tsl = require('three/tsl');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -138,9 +135,9 @@ function getPrimaryIds() {
   return Array.from(primaryRegistry.keys());
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 function useMutableCallback(fn) {
   const ref = React__namespace.useRef(fn);
@@ -171,7 +168,7 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
   return _a = class extends React__namespace.Component {
     constructor() {
       super(...arguments);
-      __publicField$1(this, "state", { error: false });
+      __publicField(this, "state", { error: false });
     }
     componentDidCatch(err) {
       this.props.set(err);
@@ -179,7 +176,7 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
     render() {
       return this.state.error ? null : this.props.children;
     }
-  }, __publicField$1(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
+  }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
 })();
 
 const is = {
@@ -1464,9 +1461,9 @@ const packageData = {
 function Xb(Tt) {
   return Tt && Tt.__esModule && Object.prototype.hasOwnProperty.call(Tt, "default") ? Tt.default : Tt;
 }
-var Rm = { exports: {} }, Og = { exports: {} }, _b$1;
+var Rm = { exports: {} }, Og = { exports: {} }, _b;
 function Kb() {
-  return _b$1 || (_b$1 = 1, (function(Tt) {
+  return _b || (_b = 1, (function(Tt) {
     Tt.exports = function(m) {
       function Yn(t, r, a, l) {
         return new uc(t, r, a, l);
@@ -13981,16 +13978,10 @@ const createStore = (invalidate, advance) => {
       },
       setError: (error) => set(() => ({ error })),
       error: null,
-      //* TSL State (managed via hooks: useUniforms, useNodes, useBuffers, useGPUStorage, useTextures, useRenderPipeline) ==============================
-      uniforms: {},
-      nodes: {},
-      buffers: {},
-      gpuStorage: {},
+      //* Texture registry (useTextures) ==============================
+      // TSL fields (uniforms, nodes, ..., renderPipeline) are added by @react-three/tsl's root extension.
       textures: /* @__PURE__ */ new Map(),
       _textureRefs: /* @__PURE__ */ new Map(),
-      renderPipeline: null,
-      passes: {},
-      _hmrVersion: 0,
       _sizeImperative: false,
       _sizeProps: null,
       previousRoot: void 0,
@@ -15326,788 +15317,6 @@ function Canvas$1(props) {
   return /* @__PURE__ */ jsxRuntime.jsx(itsFine.FiberProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(CanvasImpl, { ...props }) });
 }
 
-const RESOURCE_KINDS = ["nodes", "uniforms", "buffers", "gpuStorage"];
-const ROOT_SCOPE = "";
-const registries = /* @__PURE__ */ new WeakMap();
-function getKindRegistry(store, kind) {
-  let registry = registries.get(store);
-  if (!registry) {
-    registry = {
-      nodes: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
-      uniforms: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
-      buffers: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() },
-      gpuStorage: { valid: /* @__PURE__ */ new Set(), staged: /* @__PURE__ */ new Map() }
-    };
-    registries.set(store, registry);
-  }
-  return registry[kind];
-}
-function resolvePrimary$1(store) {
-  return store.getState().primaryStore ?? store;
-}
-function isScopeValid(store, kind, scopeKey) {
-  return getKindRegistry(store, kind).valid.has(scopeKey);
-}
-function peekStaged(store, kind, scopeKey) {
-  return getKindRegistry(store, kind).staged.get(scopeKey);
-}
-function stageEntries(store, kind, scopeKey, entries) {
-  const { staged } = getKindRegistry(store, kind);
-  const current = staged.get(scopeKey);
-  if (current) Object.assign(current, entries);
-  else staged.set(scopeKey, { ...entries });
-}
-function readCommittedScope(map, scopeKey, isLeaf) {
-  if (scopeKey === ROOT_SCOPE) {
-    const leaves = {};
-    for (const [key, value] of Object.entries(map)) if (isLeaf(value)) leaves[key] = value;
-    return leaves;
-  }
-  const scopeData = map[scopeKey];
-  if (scopeData && typeof scopeData === "object" && !isLeaf(scopeData)) return scopeData;
-  return {};
-}
-function withStagedOverlay(store, kind, committed) {
-  const { staged } = getKindRegistry(store, kind);
-  if (staged.size === 0) return committed;
-  const view = { ...committed };
-  for (const [scopeKey, entries] of staged) {
-    if (scopeKey === ROOT_SCOPE) Object.assign(view, entries);
-    else view[scopeKey] = { ...view[scopeKey], ...entries };
-  }
-  return view;
-}
-function flushStagedScope(store, kind, scopeKey, isLeaf) {
-  const registry = getKindRegistry(store, kind);
-  const staged = registry.staged.get(scopeKey);
-  if (!staged) return;
-  registry.staged.delete(scopeKey);
-  const replace = !registry.valid.has(scopeKey);
-  store.setState((state) => {
-    const map = state[kind];
-    if (scopeKey === ROOT_SCOPE) {
-      if (!replace) return { [kind]: { ...map, ...staged } };
-      const next = {};
-      for (const [key, value] of Object.entries(map)) if (!isLeaf(value)) next[key] = value;
-      return { [kind]: { ...next, ...staged } };
-    }
-    const current = replace ? {} : map[scopeKey] ?? {};
-    return { [kind]: { ...map, [scopeKey]: { ...current, ...staged } } };
-  });
-  registry.valid.add(scopeKey);
-}
-function invalidateResource(store, kind, scopeKey) {
-  const registry = getKindRegistry(store, kind);
-  if (scopeKey === void 0) {
-    registry.valid.clear();
-    registry.staged.clear();
-  } else {
-    registry.valid.delete(scopeKey);
-    registry.staged.delete(scopeKey);
-  }
-}
-function rebuildResource(store, kind, userScope) {
-  const primary = resolvePrimary$1(store);
-  invalidateResource(primary, kind, userScope === "root" ? ROOT_SCOPE : userScope);
-  primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
-}
-function invalidateAllResources(store) {
-  for (const kind of RESOURCE_KINDS) invalidateResource(store, kind);
-}
-function removeResourceEntries(store, kind, names, scope, isLeaf) {
-  const staged = peekStaged(store, kind, scope ?? ROOT_SCOPE);
-  if (staged) for (const name of names) delete staged[name];
-  store.setState((state) => {
-    const map = state[kind];
-    if (scope) {
-      const currentScope = { ...map[scope] };
-      for (const name of names) delete currentScope[name];
-      return { [kind]: { ...map, [scope]: currentScope } };
-    }
-    const next = { ...map };
-    for (const name of names) if (isLeaf(next[name])) delete next[name];
-    return { [kind]: next };
-  });
-}
-function clearResourceEntries(store, kind, scope, isLeaf) {
-  const registry = getKindRegistry(store, kind);
-  if (scope && scope !== "root") registry.staged.delete(scope);
-  else if (scope === "root") registry.staged.delete(ROOT_SCOPE);
-  else registry.staged.clear();
-  store.setState((state) => {
-    const map = state[kind];
-    if (scope && scope !== "root") {
-      const { [scope]: _, ...rest } = map;
-      return { [kind]: rest };
-    }
-    if (scope === "root") {
-      const next = {};
-      for (const [key, value] of Object.entries(map)) if (!isLeaf(value)) next[key] = value;
-      return { [kind]: next };
-    }
-    return { [kind]: {} };
-  });
-}
-
-const isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-const hasValidLegacyNodeMarkers = (value) => {
-  const hasUuid = "uuid" in value;
-  const hasNodeType = "nodeType" in value;
-  const uuid = Reflect.get(value, "uuid");
-  const nodeType = Reflect.get(value, "nodeType");
-  return (hasUuid || hasNodeType) && (!hasUuid || uuid === void 0 || typeof uuid === "string") && (!hasNodeType || nodeType === void 0 || nodeType === null || typeof nodeType === "string");
-};
-const isUniformNode = (value) => isObjectLike(value) && "isUniformNode" in value && value.isUniformNode === true;
-const isTSLNode = (value) => isObjectLike(value) && (Reflect.get(value, "isNode") === true || Reflect.get(value, "shaderNode") !== void 0 && typeof Reflect.get(value, "id") === "number" || hasValidLegacyNodeMarkers(value));
-const isBufferLike = (value) => ArrayBuffer.isView(value) && !(value instanceof DataView) || isObjectLike(value) && ("isBufferAttribute" in value || "isInterleavedBufferAttribute" in value || isTSLNode(value));
-const isStorageLike = (value) => isObjectLike(value) && ("isTexture" in value || "isData3DTexture" in value || isTSLNode(value));
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var _a, _b;
-const INTERNAL_DATA = Symbol("ScopedStore.data");
-const INTERNAL_IS_LEAF = Symbol("ScopedStore.isLeaf");
-_b = INTERNAL_DATA, _a = INTERNAL_IS_LEAF;
-const _ScopedStore = class _ScopedStore {
-  constructor(data, isLeaf) {
-    __publicField(this, _b);
-    __publicField(this, _a);
-    this[INTERNAL_DATA] = data;
-    this[INTERNAL_IS_LEAF] = isLeaf;
-    return new Proxy(this, {
-      get(target, prop, receiver) {
-        if (typeof prop === "string") {
-          if (prop === "scope" || prop === "has" || prop === "keys") {
-            return Reflect.get(target, prop, receiver);
-          }
-          return target[INTERNAL_DATA][prop];
-        }
-        return Reflect.get(target, prop, receiver);
-      },
-      has(target, prop) {
-        return typeof prop === "string" ? prop in target[INTERNAL_DATA] : Reflect.has(target, prop);
-      },
-      ownKeys(target) {
-        return Reflect.ownKeys(target[INTERNAL_DATA]);
-      },
-      getOwnPropertyDescriptor(target, prop) {
-        if (typeof prop === "string" && prop in target[INTERNAL_DATA]) {
-          return {
-            configurable: true,
-            enumerable: true,
-            value: target[INTERNAL_DATA][prop]
-          };
-        }
-        return void 0;
-      }
-    });
-  }
-  /**
-   * Access a nested scope by key.
-   * If the key doesn't exist or isn't a scope object, returns an empty ScopedStore.
-   */
-  scope(key) {
-    const value = this[INTERNAL_DATA][key];
-    const isLeaf = this[INTERNAL_IS_LEAF];
-    const scope = value && typeof value === "object" && !isLeaf(value) ? value : {};
-    return new _ScopedStore(scope, isLeaf);
-  }
-  /**
-   * Check if a key exists in the store.
-   */
-  has(key) {
-    return key in this[INTERNAL_DATA];
-  }
-  /**
-   * Get all keys in the store.
-   */
-  keys() {
-    return Object.keys(this[INTERNAL_DATA]);
-  }
-};
-let ScopedStore = _ScopedStore;
-function createScopedStore(data, isLeaf) {
-  return new ScopedStore(data, isLeaf);
-}
-function createLazyCreatorState(state, store) {
-  let _uniforms = null;
-  let _nodes = null;
-  let _buffers = null;
-  let _gpuStorage = null;
-  const view = (kind) => store ? withStagedOverlay(store, kind, state[kind]) : state[kind];
-  return Object.create(state, {
-    uniforms: {
-      get() {
-        return _uniforms ?? (_uniforms = createScopedStore(view("uniforms"), isUniformNode));
-      }
-    },
-    nodes: {
-      get() {
-        return _nodes ?? (_nodes = createScopedStore(view("nodes"), isTSLNode));
-      }
-    },
-    buffers: {
-      get() {
-        return _buffers ?? (_buffers = createScopedStore(view("buffers"), isBufferLike));
-      }
-    },
-    gpuStorage: {
-      get() {
-        return _gpuStorage ?? (_gpuStorage = createScopedStore(view("gpuStorage"), isStorageLike));
-      }
-    }
-  });
-}
-
-function resolvePrimary(local) {
-  return local.getState().primaryStore ?? local;
-}
-function usePrimaryStore() {
-  const local = useStore();
-  const primary = local.getState().primaryStore;
-  return React.useMemo(() => primary ?? local, [primary, local]);
-}
-function usePrimaryThree(selector = (state) => state, equalityFn) {
-  const local = useStore();
-  const primary = resolvePrimary(local);
-  return primary(selector, equalityFn);
-}
-
-function scopedNodeName(scope, name) {
-  const raw = scope ? `${scope}_${name}` : name;
-  const safe = raw.replace(/[^A-Za-z0-9_]/g, "_");
-  return /^[A-Za-z_]/.test(safe) ? safe : `_${safe}`;
-}
-function extractTSLValue(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value !== "object") return value;
-  const node = value;
-  if (!node.isNode) return value;
-  if (node.isConstNode) {
-    return node.value;
-  }
-  if ("value" in node) {
-    let extractedValue = node.value;
-    if (typeof node.traverse === "function") {
-      node.traverse((n) => {
-        if (n.isConstNode) {
-          extractedValue = n.value;
-        }
-      });
-    }
-    return extractedValue;
-  }
-  return value;
-}
-function vectorize(inObject) {
-  if (inObject === null || inObject === void 0) return inObject;
-  if (typeof inObject === "string") {
-    const isHexColor = /^(#|0x)[0-9a-f]{3,8}$/i.test(inObject);
-    const isNamedColor = /^[a-z]+$/i.test(inObject);
-    if (isHexColor || isNamedColor) {
-      return new webgpu.Color(inObject);
-    }
-    return inObject;
-  }
-  if (typeof inObject !== "object") return inObject;
-  const obj = inObject;
-  if (obj.isNode) {
-    return extractTSLValue(inObject);
-  }
-  if (obj.isVector2 || obj.isVector3 || obj.isVector4) return inObject;
-  if (obj.isMatrix2 || obj.isMatrix3 || obj.isMatrix4) return inObject;
-  if (obj.isColor || obj.isEuler || obj.isQuaternion || obj.isSpherical) return inObject;
-  if ("r" in obj && "g" in obj && "b" in obj && typeof obj.r === "number" && typeof obj.g === "number" && typeof obj.b === "number") {
-    const scale = obj.r > 1 || obj.g > 1 || obj.b > 1 ? 1 / 255 : 1;
-    return new webgpu.Color(obj.r * scale, obj.g * scale, obj.b * scale);
-  }
-  if ("x" in obj && "y" in obj && typeof obj.x === "number" && typeof obj.y === "number") {
-    if ("w" in obj && typeof obj.w === "number" && "z" in obj && typeof obj.z === "number") {
-      return new webgpu.Vector4(obj.x, obj.y, obj.z, obj.w);
-    }
-    if ("z" in obj && typeof obj.z === "number") {
-      return new webgpu.Vector3(obj.x, obj.y, obj.z);
-    }
-    return new webgpu.Vector2(obj.x, obj.y);
-  }
-  return inObject;
-}
-
-function useCompareMemoize(value, deep) {
-  const ref = React.useRef(value);
-  const compare = lite.dequal ;
-  if (!compare(value, ref.current)) {
-    ref.current = value;
-  }
-  return ref.current;
-}
-
-function clearHmrCaches(store) {
-  const primary = store.getState().primaryStore ?? store;
-  invalidateAllResources(primary);
-  primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
-}
-
-const SHARED_KEYS = ["uniforms", "nodes", "buffers", "gpuStorage", "_hmrVersion"];
-const following = /* @__PURE__ */ new WeakMap();
-function followPrimary(store) {
-  const primary = store.getState().primaryStore;
-  if (!primary || primary === store) return;
-  const sync = () => {
-    const source = primary.getState();
-    const target = store.getState();
-    let patch = null;
-    for (const key of SHARED_KEYS) {
-      if (target[key] !== source[key]) (patch ?? (patch = {}))[key] = source[key];
-    }
-    if (patch) store.setState(patch);
-  };
-  sync();
-  following.set(store, primary.subscribe(sync));
-}
-function stopFollowing(store) {
-  following.get(store)?.();
-  following.delete(store);
-}
-let registered = false;
-function ensureTSLExtension() {
-  if (registered) return;
-  registered = true;
-  registerRootExtension({
-    name: "@react-three/tsl",
-    setup: followPrimary,
-    dispose: stopFollowing,
-    // Resolves primaryStore itself, so every canvas sharing a renderer refreshes the same resources.
-    hmr: clearHmrCaches
-  });
-}
-
-ensureTSLExtension();
-function useScopedResource(options) {
-  const { store, kind, scope, isLeaf, create, prepare, reconcile, input } = options;
-  const scopeKey = scope ?? ROOT_SCOPE;
-  const version = store((s) => s._hmrVersion);
-  const entries = React.useMemo(() => {
-    const staged = peekStaged(store, kind, scopeKey);
-    const reusable = isScopeValid(store, kind, scopeKey);
-    const map = store.getState()[kind];
-    const committed = reusable ? readCommittedScope(map, scopeKey, isLeaf) : void 0;
-    const result = {};
-    let fresh = null;
-    for (const [name, candidate] of Object.entries(create())) {
-      const existing = staged?.[name] ?? committed?.[name];
-      if (existing !== void 0) {
-        result[name] = existing;
-        reconcile?.(existing, candidate);
-      } else {
-        const value = prepare ? prepare(name, candidate) : candidate;
-        result[name] = value;
-        (fresh ?? (fresh = {}))[name] = value;
-      }
-    }
-    if (fresh) stageEntries(store, kind, scopeKey, fresh);
-    return result;
-  }, [store, kind, scopeKey, version, input]);
-  useIsomorphicLayoutEffect(() => {
-    flushStagedScope(store, kind, scopeKey, isLeaf);
-  });
-  return entries;
-}
-
-function useUniforms(creatorOrScope, scope) {
-  const store = usePrimaryStore();
-  const removeUniforms2 = React.useCallback(
-    (names, targetScope) => removeResourceEntries(store, "uniforms", Array.isArray(names) ? names : [names], targetScope, isUniformNode),
-    [store]
-  );
-  const clearUniforms = React.useCallback(
-    (targetScope) => clearResourceEntries(store, "uniforms", targetScope, isUniformNode),
-    [store]
-  );
-  const rebuildUniforms = React.useCallback(
-    (targetScope) => rebuildResource(store, "uniforms", targetScope),
-    [store]
-  );
-  const processedInput = React.useMemo(() => {
-    let raw = creatorOrScope;
-    if (is.fun(creatorOrScope)) {
-      const wrappedState = createLazyCreatorState(store.getState(), store);
-      raw = creatorOrScope(wrappedState);
-    }
-    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-      const normalized = {};
-      for (const [key, value] of Object.entries(raw)) {
-        normalized[key] = vectorize(value);
-      }
-      return { candidates: raw, normalized };
-    }
-    return { candidates: raw, normalized: raw };
-  }, [creatorOrScope, store]);
-  const memoizedInput = useCompareMemoize(processedInput.normalized);
-  const isReader = memoizedInput === void 0 || typeof memoizedInput === "string";
-  const storeUniforms = usePrimaryThree((s) => s.uniforms);
-  const created = useScopedResource({
-    store,
-    kind: "uniforms",
-    scope: isReader ? void 0 : scope,
-    isLeaf: isUniformNode,
-    input: memoizedInput,
-    create: () => {
-      if (isReader) return {};
-      if (typeof processedInput.candidates !== "object" || processedInput.candidates === null)
-        throw new Error("Invalid uniform input");
-      return processedInput.candidates;
-    },
-    prepare: (name, candidate) => createUniform(name, candidate, scope),
-    reconcile: (existing, candidate) => {
-      const existingVal = existing.value;
-      const newVal = vectorize(candidate);
-      let equals = newVal === existingVal;
-      if (!equals && hasEqualsMethod(existingVal) && hasEqualsMethod(newVal)) {
-        if (isThreeVector(existingVal) && isThreeVector(newVal)) {
-          equals = vectorEquals(existingVal, newVal);
-        } else if (isSameThreeType(existingVal, newVal)) {
-          equals = existingVal.equals(newVal);
-        }
-      }
-      if (!equals) existing.value = newVal;
-    }
-  });
-  let uniforms = created;
-  if (memoizedInput === void 0) {
-    uniforms = storeUniforms;
-  } else if (typeof memoizedInput === "string") {
-    const scopeData = storeUniforms[memoizedInput];
-    uniforms = scopeData && !isUniformNode(scopeData) ? scopeData : {};
-  }
-  return { ...uniforms, removeUniforms: removeUniforms2, clearUniforms, rebuildUniforms };
-}
-function rebuildAllUniforms(store, scope) {
-  rebuildResource(store, "uniforms", scope);
-}
-function removeUniforms(set, names, scope) {
-  set((state) => {
-    if (scope) {
-      const currentScope = { ...state.uniforms[scope] };
-      for (const name of names) delete currentScope[name];
-      return { uniforms: { ...state.uniforms, [scope]: currentScope } };
-    }
-    const uniforms = { ...state.uniforms };
-    for (const name of names) if (isUniformNode(uniforms[name])) delete uniforms[name];
-    return { uniforms };
-  });
-}
-function clearScope(set, scope) {
-  set((state) => {
-    const { [scope]: _, ...rest } = state.uniforms;
-    return { uniforms: rest };
-  });
-}
-function clearRootUniforms(set) {
-  set((state) => {
-    const uniforms = {};
-    for (const [key, value] of Object.entries(state.uniforms)) {
-      if (!isUniformNode(value)) uniforms[key] = value;
-    }
-    return { uniforms };
-  });
-}
-function createUniform(inName, node, scope) {
-  if (node.type === "UniformNode") return node;
-  const inValue = vectorize(node);
-  const newUniform = tsl.uniform(inValue);
-  if (typeof newUniform.setName === "function") {
-    newUniform.setName(scopedNodeName(scope, inName));
-  }
-  return newUniform;
-}
-function isThreeVector(inVector) {
-  if (!inVector) return false;
-  return inVector.isVector2 || inVector.isVector3 || inVector.isVector4;
-}
-function vectorEquals(a, b) {
-  if (a.isVector2 && b.isVector2) {
-    return a.equals(b);
-  }
-  if (a.isVector3 && b.isVector3) {
-    return a.equals(b);
-  }
-  if (a.isVector4 && b.isVector4) {
-    return a.equals(b);
-  }
-  return false;
-}
-function hasEqualsMethod(value) {
-  return value !== null && typeof value === "object" && "equals" in value && typeof value.equals === "function";
-}
-function isSameThreeType(a, b) {
-  const obj_a = a;
-  const obj_b = b;
-  return obj_a.isColor && obj_b.isColor || obj_a.isMatrix2 && obj_b.isMatrix2 || obj_a.isMatrix3 && obj_b.isMatrix3 || obj_a.isMatrix4 && obj_b.isMatrix4 || obj_a.isEuler && obj_b.isEuler || obj_a.isQuaternion && obj_b.isQuaternion;
-}
-
-const uniformOf = tsl.uniform;
-function useUniform(name, value) {
-  const store = usePrimaryStore();
-  const registered = useScopedResource({
-    store,
-    kind: "uniforms",
-    scope: void 0,
-    isLeaf: isUniformNode,
-    input: name,
-    create: () => value === void 0 ? {} : { [name]: value },
-    prepare: createNamedUniform,
-    reconcile: (existing2) => {
-      if (value !== void 0 && !isTSLNode(value) && !isUniformNode(value)) {
-        existing2.value = typeof value === "string" ? new webgpu.Color(value) : value;
-      }
-    }
-  });
-  if (registered[name]) return registered[name];
-  const existing = peekStaged(store, "uniforms", ROOT_SCOPE)?.[name] ?? store.getState().uniforms[name];
-  if (existing && isUniformNode(existing)) return existing;
-  throw new Error(
-    `[useUniform] Uniform "${name}" not found. Create it first with: useUniform('${name}', initialValue)`
-  );
-}
-function createNamedUniform(name, value) {
-  let node;
-  if (isUniformNode(value)) {
-    node = value;
-  } else if (isTSLNode(value)) {
-    node = uniformOf(value);
-  } else if (typeof value === "string") {
-    node = tsl.uniform(new webgpu.Color(value));
-  } else {
-    node = uniformOf(value);
-  }
-  if (typeof node.setName === "function") {
-    node.setName(name);
-  }
-  return node;
-}
-
-function useNodes(creatorOrScope, scope) {
-  const store = usePrimaryStore();
-  const removeNodes2 = React.useCallback(
-    (names, targetScope) => removeResourceEntries(store, "nodes", Array.isArray(names) ? names : [names], targetScope, isTSLNode),
-    [store]
-  );
-  const clearNodes = React.useCallback(
-    (targetScope) => clearResourceEntries(store, "nodes", targetScope, isTSLNode),
-    [store]
-  );
-  const rebuildNodes = React.useCallback(
-    (targetScope) => rebuildResource(store, "nodes", targetScope),
-    [store]
-  );
-  const isReader = creatorOrScope === void 0 || typeof creatorOrScope === "string";
-  const storeNodes = usePrimaryThree((s) => s.nodes);
-  const created = useScopedResource({
-    store,
-    kind: "nodes",
-    scope: isReader ? void 0 : scope,
-    isLeaf: isTSLNode,
-    create: () => {
-      if (isReader) return {};
-      return creatorOrScope(createLazyCreatorState(store.getState(), store));
-    },
-    prepare: (name, node) => {
-      const setName = Reflect.get(node, "setName");
-      if (typeof setName === "function") setName.call(node, scopedNodeName(scope, name));
-      return node;
-    }
-  });
-  let nodes = created;
-  if (creatorOrScope === void 0) {
-    nodes = storeNodes;
-  } else if (typeof creatorOrScope === "string") {
-    const scopeData = storeNodes[creatorOrScope];
-    nodes = scopeData && !isTSLNode(scopeData) ? scopeData : {};
-  }
-  return { ...nodes, removeNodes: removeNodes2, clearNodes, rebuildNodes };
-}
-function rebuildAllNodes(store, scope) {
-  rebuildResource(store, "nodes", scope);
-}
-function removeNodes(set, names, scope) {
-  set((state) => {
-    if (scope) {
-      const currentScope = { ...state.nodes[scope] };
-      for (const name of names) delete currentScope[name];
-      return { nodes: { ...state.nodes, [scope]: currentScope } };
-    }
-    const nodes = { ...state.nodes };
-    for (const name of names) if (isTSLNode(nodes[name])) delete nodes[name];
-    return { nodes };
-  });
-}
-function clearNodeScope(set, scope) {
-  set((state) => {
-    const { [scope]: _, ...rest } = state.nodes;
-    return { nodes: rest };
-  });
-}
-function clearRootNodes(set) {
-  set((state) => {
-    const nodes = {};
-    for (const [key, value] of Object.entries(state.nodes)) {
-      if (!isTSLNode(value)) nodes[key] = value;
-    }
-    return { nodes };
-  });
-}
-function useLocalNodes(creator) {
-  const store = usePrimaryStore();
-  const uniforms = usePrimaryThree((s) => s.uniforms);
-  const nodes = usePrimaryThree((s) => s.nodes);
-  const textures = usePrimaryThree((s) => s.textures);
-  const hmrVersion = usePrimaryThree((s) => s._hmrVersion);
-  return React.useMemo(() => {
-    const wrappedState = createLazyCreatorState(store.getState(), store);
-    return creator(wrappedState);
-  }, [store, creator, uniforms, nodes, textures, hmrVersion]);
-}
-
-const disposeBuffer = (buffer) => {
-  if (buffer === null || typeof buffer !== "object") return;
-  if ("dispose" in buffer && typeof buffer.dispose === "function") {
-    buffer.dispose();
-  }
-};
-function useBuffers(creatorOrScope, scope) {
-  const store = usePrimaryStore();
-  const removeBuffers = React.useCallback(
-    (names, targetScope) => removeResourceEntries(store, "buffers", Array.isArray(names) ? names : [names], targetScope, isBufferLike),
-    [store]
-  );
-  const clearBuffers = React.useCallback(
-    (targetScope) => clearResourceEntries(store, "buffers", targetScope, isBufferLike),
-    [store]
-  );
-  const rebuildBuffers = React.useCallback(
-    (targetScope) => rebuildResource(store, "buffers", targetScope),
-    [store]
-  );
-  const disposeBuffers = React.useCallback(
-    (names, targetScope) => {
-      const nameArray = Array.isArray(names) ? names : [names];
-      const state = store.getState();
-      for (const name of nameArray) {
-        const buffer = targetScope ? state.buffers[targetScope]?.[name] : state.buffers[name];
-        if (buffer && isBufferLike(buffer)) {
-          disposeBuffer(buffer);
-        }
-      }
-      removeBuffers(names, targetScope);
-    },
-    [store, removeBuffers]
-  );
-  const isReader = creatorOrScope === void 0 || typeof creatorOrScope === "string";
-  const storeBuffers = usePrimaryThree((s) => s.buffers);
-  const created = useScopedResource({
-    store,
-    kind: "buffers",
-    scope: isReader ? void 0 : scope,
-    isLeaf: isBufferLike,
-    create: () => {
-      if (isReader) return {};
-      return creatorOrScope(createLazyCreatorState(store.getState(), store));
-    },
-    prepare: (name, buffer) => {
-      const setName = Reflect.get(buffer, "setName");
-      if (typeof setName === "function") setName.call(buffer, scopedNodeName(scope, name));
-      return buffer;
-    }
-  });
-  let buffers = created;
-  if (creatorOrScope === void 0) {
-    buffers = storeBuffers;
-  } else if (typeof creatorOrScope === "string") {
-    const scopeData = storeBuffers[creatorOrScope];
-    buffers = scopeData && !isBufferLike(scopeData) ? scopeData : {};
-  }
-  return { ...buffers, removeBuffers, clearBuffers, rebuildBuffers, disposeBuffers };
-}
-function rebuildAllBuffers(store, scope) {
-  rebuildResource(store, "buffers", scope);
-}
-
-const disposeStorage = (storage) => {
-  if (storage === null || typeof storage !== "object") return;
-  if ("dispose" in storage && typeof storage.dispose === "function") {
-    storage.dispose();
-  }
-};
-function useGPUStorage(creatorOrScope, scope) {
-  const store = usePrimaryStore();
-  const removeStorage = React.useCallback(
-    (names, targetScope) => removeResourceEntries(store, "gpuStorage", Array.isArray(names) ? names : [names], targetScope, isStorageLike),
-    [store]
-  );
-  const clearStorage = React.useCallback(
-    (targetScope) => clearResourceEntries(store, "gpuStorage", targetScope, isStorageLike),
-    [store]
-  );
-  const rebuildStorage = React.useCallback(
-    (targetScope) => rebuildResource(store, "gpuStorage", targetScope),
-    [store]
-  );
-  const disposeStorageFn = React.useCallback(
-    (names, targetScope) => {
-      const nameArray = Array.isArray(names) ? names : [names];
-      const state = store.getState();
-      for (const name of nameArray) {
-        const storage = targetScope ? state.gpuStorage[targetScope]?.[name] : state.gpuStorage[name];
-        if (storage && isStorageLike(storage)) {
-          disposeStorage(storage);
-        }
-      }
-      removeStorage(names, targetScope);
-    },
-    [store, removeStorage]
-  );
-  const isReader = creatorOrScope === void 0 || typeof creatorOrScope === "string";
-  const storeStorage = usePrimaryThree((s) => s.gpuStorage);
-  const created = useScopedResource({
-    store,
-    kind: "gpuStorage",
-    scope: isReader ? void 0 : scope,
-    isLeaf: isStorageLike,
-    create: () => {
-      if (isReader) return {};
-      return creatorOrScope(createLazyCreatorState(store.getState(), store));
-    },
-    prepare: (name, storage) => {
-      const label = scopedNodeName(scope, name);
-      const setName = Reflect.get(storage, "setName");
-      if (typeof setName === "function") setName.call(storage, label);
-      if ("name" in storage && typeof storage.name === "string") {
-        storage.name = label;
-      }
-      return storage;
-    }
-  });
-  let gpuStorage = created;
-  if (creatorOrScope === void 0) {
-    gpuStorage = storeStorage;
-  } else if (typeof creatorOrScope === "string") {
-    const scopeData = storeStorage[creatorOrScope];
-    gpuStorage = scopeData && !isStorageLike(scopeData) ? scopeData : {};
-  }
-  return {
-    ...gpuStorage,
-    removeStorage,
-    clearStorage,
-    rebuildStorage,
-    disposeStorage: disposeStorageFn
-  };
-}
-function rebuildAllStorage(store, scope) {
-  rebuildResource(store, "gpuStorage", scope);
-}
-
 function addTexture(set, key, value) {
   set((state) => {
     const newMap = new Map(state.textures);
@@ -16148,127 +15357,6 @@ function createTextureOperations(set) {
   };
 }
 
-function renderThroughPipeline(store) {
-  return () => {
-    const pipeline = store.getState().renderPipeline;
-    if (pipeline?.render) pipeline.render();
-  };
-}
-function useRenderPipeline(mainCB, setupCB) {
-  const store = useStore();
-  const { scene, camera, renderer, isLegacy } = useThree$1();
-  const callbacksRanRef = React.useRef(false);
-  const scenePassCacheRef = React.useRef(null);
-  const forceScenePassRebuildRef = React.useRef(false);
-  const mainCBRef = React.useRef(mainCB);
-  const setupCBRef = React.useRef(setupCB);
-  mainCBRef.current = mainCB;
-  setupCBRef.current = setupCB;
-  const [rebuildVersion, setRebuildVersion] = React.useState(0);
-  React.useEffect(() => {
-    callbacksRanRef.current = false;
-    forceScenePassRebuildRef.current = true;
-  }, []);
-  const clearPasses = React.useCallback(() => {
-    store.setState({ passes: {} });
-  }, [store]);
-  const reset = React.useCallback(() => {
-    store.setState({
-      renderPipeline: null,
-      passes: {}
-    });
-    setRenderOverride(store, null);
-    scenePassCacheRef.current?.scenePass.dispose();
-    callbacksRanRef.current = false;
-    scenePassCacheRef.current = null;
-    forceScenePassRebuildRef.current = false;
-  }, [store]);
-  const rebuild = React.useCallback(() => {
-    callbacksRanRef.current = false;
-    forceScenePassRebuildRef.current = true;
-    setRebuildVersion((v) => v + 1);
-  }, []);
-  React.useLayoutEffect(() => {
-    if (isLegacy) {
-      throw new Error("useRenderPipeline is only available with WebGPU renderer. Set renderer prop on Canvas.");
-    }
-    if (!renderer || !scene || !camera) return;
-    if (!("isWebGPURenderer" in renderer)) {
-      throw new Error("useRenderPipeline: renderer is not a WebGPURenderer but isLegacy is false.");
-    }
-    const state = store.getState();
-    const set = store.setState;
-    try {
-      let pipeline = state.renderPipeline;
-      let currentPasses = { ...state.passes };
-      let justCreatedPipeline = false;
-      if (!pipeline) {
-        pipeline = new webgpu.RenderPipeline(renderer);
-        justCreatedPipeline = true;
-      }
-      const cacheValid = !forceScenePassRebuildRef.current && scenePassCacheRef.current && scenePassCacheRef.current.sceneUuid === scene.uuid && scenePassCacheRef.current.cameraUuid === camera.uuid;
-      let outgoingScenePass = null;
-      let scenePass;
-      if (cacheValid) {
-        scenePass = scenePassCacheRef.current.scenePass;
-      } else {
-        outgoingScenePass = scenePassCacheRef.current?.scenePass ?? null;
-        scenePass = tsl.pass(scene, camera);
-        scenePassCacheRef.current = { sceneUuid: scene.uuid, cameraUuid: camera.uuid, scenePass };
-        forceScenePassRebuildRef.current = false;
-      }
-      currentPasses.scenePass = scenePass;
-      let outputNodeChanged = false;
-      if (!pipeline.outputNode || justCreatedPipeline || pipeline.outputNode === outgoingScenePass) {
-        pipeline.outputNode = scenePass;
-        outputNodeChanged = true;
-      }
-      set({ renderPipeline: pipeline, passes: currentPasses });
-      setRenderOverride(store, renderThroughPipeline(store));
-      const shouldRunCallbacks = justCreatedPipeline || !callbacksRanRef.current || !cacheValid;
-      if (shouldRunCallbacks) {
-        if (setupCBRef.current) {
-          const freshState = Object.assign({}, store.getState(), {
-            renderPipeline: pipeline,
-            passes: { ...currentPasses, scenePass },
-            renderer,
-            isLegacy: false
-          });
-          const setupResult = setupCBRef.current(freshState);
-          if (setupResult && typeof setupResult === "object") {
-            currentPasses = { ...currentPasses, ...setupResult };
-            set({ passes: currentPasses });
-          }
-        }
-        if (mainCBRef.current) {
-          const freshState = Object.assign({}, store.getState(), {
-            renderPipeline: pipeline,
-            passes: { ...currentPasses, scenePass },
-            renderer,
-            isLegacy: false
-          });
-          const mainResult = mainCBRef.current(freshState);
-          if (mainResult && typeof mainResult === "object") {
-            currentPasses = { ...currentPasses, ...mainResult };
-            set({ passes: currentPasses });
-          }
-        }
-        outputNodeChanged = true;
-        callbacksRanRef.current = true;
-      }
-      if (outputNodeChanged) pipeline.needsUpdate = true;
-      if (outgoingScenePass && outgoingScenePass !== scenePass) outgoingScenePass.dispose();
-    } catch (error) {
-      console.warn("[useRenderPipeline] Setup failed; the render pipeline was not configured:", error);
-    }
-  }, [store, renderer, scene, camera, isLegacy, rebuildVersion]);
-  const passes = useThree$1((s) => s.passes);
-  const renderPipeline = useThree$1((s) => s.renderPipeline);
-  const actions = { passes, clearPasses, reset, rebuild };
-  if (renderPipeline) return { ...actions, isReady: true, renderPipeline };
-  return { ...actions, isReady: false, renderPipeline: null };
-}
-
 extend(THREE);
 const useThree = useThree$1;
 const useFrame = useFrame$1;
@@ -16301,16 +15389,11 @@ exports.applyProps = applyProps;
 exports.attach = attach;
 exports.buildGraph = buildGraph;
 exports.calculateDpr = calculateDpr;
-exports.clearNodeScope = clearNodeScope;
-exports.clearRootNodes = clearRootNodes;
-exports.clearRootUniforms = clearRootUniforms;
-exports.clearScope = clearScope;
 exports.context = context;
 exports.createEvents = createEvents;
 exports.createPointerEvents = createPointerEvents;
 exports.createPortal = createPortal;
 exports.createRoot = createRoot;
-exports.createScopedStore = createScopedStore;
 exports.createStore = createStore;
 exports.createTextureOperations = createTextureOperations;
 exports.detach = detach;
@@ -16344,16 +15427,10 @@ exports.isVectorLike = isVectorLike;
 exports.once = once;
 exports.prepare = prepare;
 exports.presetsObj = presetsObj;
-exports.rebuildAllBuffers = rebuildAllBuffers;
-exports.rebuildAllNodes = rebuildAllNodes;
-exports.rebuildAllStorage = rebuildAllStorage;
-exports.rebuildAllUniforms = rebuildAllUniforms;
 exports.reconciler = reconciler;
 exports.registerPrimary = registerPrimary;
 exports.registerRootExtension = registerRootExtension;
 exports.removeInteractivity = removeInteractivity;
-exports.removeNodes = removeNodes;
-exports.removeUniforms = removeUniforms;
 exports.resolve = resolve;
 exports.setRenderOverride = setRenderOverride;
 exports.swapInteractivity = swapInteractivity;
@@ -16362,23 +15439,16 @@ exports.unregisterPrimary = unregisterPrimary;
 exports.updateCamera = updateCamera;
 exports.updateFrustum = updateFrustum;
 exports.useBridge = useBridge;
-exports.useBuffers = useBuffers;
 exports.useEnvironment = useEnvironment;
 exports.useFrame = useFrame;
-exports.useGPUStorage = useGPUStorage;
 exports.useGraph = useGraph;
 exports.useInstanceHandle = useInstanceHandle;
 exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;
 exports.useLoader = useLoader;
-exports.useLocalNodes = useLocalNodes;
 exports.useMutableCallback = useMutableCallback;
-exports.useNodes = useNodes;
-exports.useRenderPipeline = useRenderPipeline;
 exports.useRenderTarget = useRenderTarget;
 exports.useStore = useStore;
 exports.useTexture = useTexture;
 exports.useTextures = useTextures;
 exports.useThree = useThree;
-exports.useUniform = useUniform;
-exports.useUniforms = useUniforms;
 exports.waitForPrimary = waitForPrimary;