@react-three/tsl 10.0.0-canary.490e4992

package/dist/index.cjs

@@ -0,0 +1,935 @@
+'use strict';
+
+const extension = require('@react-three/fiber/extension');
+const tsl = require('three/tsl');
+const THREE = require('three/webgpu');
+const React = require('react');
+const lite = require('dequal/lite');
+require('zustand/shallow');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const THREE__namespace = /*#__PURE__*/_interopNamespaceCompat(THREE);
+const React__namespace = /*#__PURE__*/_interopNamespaceCompat(React);
+
+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]: {} };
+  });
+}
+
+function clearHmrCaches(store) {
+  const primary = store.getState().primaryStore ?? store;
+  invalidateAllResources(primary);
+  primary.setState((state) => ({ _hmrVersion: state._hmrVersion + 1 }));
+}
+
+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));
+
+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 THREE__namespace.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 THREE__namespace.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 THREE__namespace.Vector4(obj.x, obj.y, obj.z, obj.w);
+    }
+    if ("z" in obj && typeof obj.z === "number") {
+      return new THREE__namespace.Vector3(obj.x, obj.y, obj.z);
+    }
+    return new THREE__namespace.Vector2(obj.x, obj.y);
+  }
+  return inObject;
+}
+
+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;
+}
+
+const primaries = /* @__PURE__ */ new Set();
+let config = null;
+function trackPrimary(store) {
+  primaries.add(store);
+  if (config) applyConfig(store, config);
+}
+function untrackPrimary(store) {
+  primaries.delete(store);
+}
+function applyConfig(store, config2) {
+  const add = (scope, inputs) => {
+    if (!inputs) return;
+    const scopeKey = scope ?? ROOT_SCOPE;
+    const existing = readCommittedScope(store.getState().uniforms, scopeKey, isUniformNode);
+    const fresh = {};
+    for (const [name, value] of Object.entries(inputs)) {
+      if (!(name in existing)) fresh[name] = createUniform(name, value, scope);
+    }
+    if (!Object.keys(fresh).length) return;
+    stageEntries(store, "uniforms", scopeKey, fresh);
+    flushStagedScope(store, "uniforms", scopeKey, isUniformNode);
+  };
+  add(void 0, config2.uniforms);
+  for (const [scope, inputs] of Object.entries(config2.scopes ?? {})) add(scope, inputs);
+}
+function configureTSL(next) {
+  config = {
+    uniforms: { ...config?.uniforms, ...next.uniforms },
+    scopes: { ...config?.scopes, ...next.scopes }
+  };
+  for (const store of primaries) applyConfig(store, config);
+}
+
+const SHARED_KEYS = ["uniforms", "nodes", "buffers", "gpuStorage", "_hmrVersion"];
+const following = /* @__PURE__ */ new WeakMap();
+function createResourceState() {
+  return { uniforms: {}, nodes: {}, buffers: {}, gpuStorage: {}, _hmrVersion: 0 };
+}
+function setup(store) {
+  const primary = store.getState().primaryStore;
+  if (!primary || primary === store) {
+    store.setState(createResourceState());
+    trackPrimary(store);
+    return;
+  }
+  followPrimary(store, primary);
+}
+function followPrimary(store, primary) {
+  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 dispose(store) {
+  untrackPrimary(store);
+  following.get(store)?.();
+  following.delete(store);
+}
+let registered = false;
+function ensureTSLExtension() {
+  if (registered) return;
+  registered = true;
+  extension.registerRootExtension({
+    name: "@react-three/tsl",
+    setup,
+    dispose,
+    // Resolves primaryStore itself, so every canvas sharing a renderer refreshes the same resources.
+    hmr: clearHmrCaches
+  });
+}
+
+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 = extension.useStore();
+  const primary = local.getState().primaryStore;
+  return React.useMemo(() => primary ?? local, [primary, local]);
+}
+function usePrimaryThree(selector = (state) => state, equalityFn) {
+  const local = extension.useStore();
+  const primary = resolvePrimary(local);
+  return primary(selector, equalityFn);
+}
+
+function useCompareMemoize(value, deep) {
+  const ref = React.useRef(value);
+  const compare = lite.dequal ;
+  if (!compare(value, ref.current)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+
+const useIsomorphicLayoutEffect = typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative") ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+
+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 removeUniforms = 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 (typeof creatorOrScope === "function") {
+      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, clearUniforms, rebuildUniforms };
+}
+function rebuildAllUniforms(store, scope) {
+  rebuildResource(store, "uniforms", scope);
+}
+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 THREE.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 THREE.Color(value));
+  } else {
+    node = uniformOf(value);
+  }
+  if (typeof node.setName === "function") {
+    node.setName(name);
+  }
+  return node;
+}
+
+function useNodes(creatorOrScope, scope) {
+  const store = usePrimaryStore();
+  const removeNodes = 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, clearNodes, rebuildNodes };
+}
+function rebuildAllNodes(store, scope) {
+  rebuildResource(store, "nodes", scope);
+}
+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);
+}
+
+const NO_PASSES = Object.freeze({});
+function renderThroughPipeline(store) {
+  return () => {
+    const pipeline = store.getState().renderPipeline;
+    if (pipeline?.render) pipeline.render();
+  };
+}
+function useRenderPipeline(mainCB, setupCB) {
+  const store = extension.useStore();
+  const { scene, camera, renderer, isLegacy } = extension.useThree();
+  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: {}
+    });
+    extension.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 ?? null;
+      let currentPasses = { ...state.passes };
+      let justCreatedPipeline = false;
+      if (!pipeline) {
+        pipeline = new THREE__namespace.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 });
+      extension.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 = extension.useThree((s) => s.passes) ?? NO_PASSES;
+  const renderPipeline = extension.useThree((s) => s.renderPipeline) ?? null;
+  const actions = { passes, clearPasses, reset, rebuild };
+  if (renderPipeline) return { ...actions, isReady: true, renderPipeline };
+  return { ...actions, isReady: false, renderPipeline: null };
+}
+
+ensureTSLExtension();
+
+exports.configureTSL = configureTSL;
+exports.createScopedStore = createScopedStore;
+exports.rebuildAllBuffers = rebuildAllBuffers;
+exports.rebuildAllNodes = rebuildAllNodes;
+exports.rebuildAllStorage = rebuildAllStorage;
+exports.rebuildAllUniforms = rebuildAllUniforms;
+exports.useBuffers = useBuffers;
+exports.useGPUStorage = useGPUStorage;
+exports.useLocalNodes = useLocalNodes;
+exports.useNodes = useNodes;
+exports.useRenderPipeline = useRenderPipeline;
+exports.useUniform = useUniform;
+exports.useUniforms = useUniforms;