@react-three/tsl 10.0.0-canary.04087d8

package/dist/index.mjs

@@ -0,0 +1,1208 @@
+import { registerRootExtension, getTextureView, useStore, useThree, setRenderOverride } from '@react-three/fiber/extension';
+import { uniform, pass } from 'three/tsl';
+import * as THREE from 'three/webgpu';
+import { Color } from 'three/webgpu';
+import * as React from 'react';
+import { useMemo, useRef, useCallback, useSyncExternalStore, useState, useEffect, useLayoutEffect } from 'react';
+import { dequal } from 'dequal/lite';
+import 'zustand/shallow';
+
+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 (node.isVarNode && node.node) {
+    const inner = extractTSLValue(node.node);
+    return inner === node.node ? value : inner;
+  }
+  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.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.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.Vector4(obj.x, obj.y, obj.z, obj.w);
+    }
+    if ("z" in obj && typeof obj.z === "number") {
+      return new THREE.Vector3(obj.x, obj.y, obj.z);
+    }
+    return new THREE.Vector2(obj.x, obj.y);
+  }
+  return inObject;
+}
+
+function createUniform(inName, node, scope) {
+  if (node.type === "UniformNode") return node;
+  const inValue = vectorize(node);
+  const newUniform = 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;
+  registerRootExtension({
+    name: "@react-three/tsl",
+    setup,
+    dispose,
+    // Resolves primaryStore itself, so every canvas sharing a renderer refreshes the same resources.
+    hmr: clearHmrCaches
+  });
+}
+
+const SCOPE = Symbol("readTracking.scope");
+const LEAF_GUARDS = {
+  uniforms: isUniformNode,
+  nodes: isTSLNode,
+  buffers: isBufferLike,
+  gpuStorage: isStorageLike
+};
+function isScope(kind, value) {
+  return !!value && typeof value === "object" && !LEAF_GUARDS[kind](value);
+}
+function classify(kind, value) {
+  return kind !== "textures" && isScope(kind, value) ? SCOPE : value;
+}
+function resolveContainer(kind, root, scopePath) {
+  let container = root;
+  for (const key of scopePath) {
+    const next = container?.[key];
+    container = isScope(kind, next) ? next : void 0;
+  }
+  return container;
+}
+function observeNow(read, view) {
+  if (read.kind === "textures") {
+    const map = view("textures");
+    if (read.op === "keys") return [...map.keys()];
+    return read.op === "has" ? map.has(read.path[0]) : map.get(read.path[0]);
+  }
+  const root = view(read.kind);
+  if (read.op === "keys") return Object.keys(resolveContainer(read.kind, root, read.path) ?? {});
+  const container = resolveContainer(read.kind, root, read.path.slice(0, -1));
+  const key = read.path[read.path.length - 1];
+  if (read.op === "has") return !!container && key in container;
+  return classify(read.kind, container?.[key]);
+}
+function sameKeys(a, b) {
+  return a.length === b.length && a.every((key, i) => key === b[i]);
+}
+function hasChanged(read, view) {
+  const now = observeNow(read, view);
+  return read.op === "keys" ? !sameKeys(read.seen, now) : !Object.is(read.seen, now);
+}
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(message);
+}
+function describeRead(kind, path) {
+  if (kind === "textures") return `textures.get('${path[0]}')`;
+  const scopes = path.slice(0, -1).map((key) => `.scope('${key}')`);
+  return `${kind}${scopes.join("")}.${path[path.length - 1] ?? ""}`;
+}
+function createReadTracker(hookName) {
+  const tracker = {
+    reads: [],
+    closed: false,
+    stale: false,
+    observe: (read) => {
+      if (tracker.closed) {
+        warnOnce(
+          `[${hookName}] ${describeRead(read.kind, read.path)} was read after the creator returned, probably inside Fn(). That read is not tracked, so replacing the resource will not rebuild this graph. Read the resource in the creator and close over it in Fn.`
+        );
+        return;
+      }
+      tracker.reads.push(read);
+    }
+  };
+  return tracker;
+}
+function isTrackerStale(tracker, view) {
+  if (!tracker.stale) tracker.stale = tracker.reads.some((read) => hasChanged(read, view));
+  return tracker.stale;
+}
+function warnMissingReads(hookName) {
+  return {
+    nested: false,
+    observe: (read) => {
+      if (read.op !== "get" || read.seen !== void 0) return;
+      warnOnce(
+        `[${hookName}] The creator read ${describeRead(read.kind, read.path)}, which does not exist yet. ${hookName} creators run once per generation, so this one will not re-run when it appears. Register it earlier (above this hook, or higher in the tree), or call rebuild* once it exists. To probe on purpose, use .has().`
+      );
+    }
+  };
+}
+
+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, _c, _d;
+const INTERNAL_DATA = Symbol("ScopedStore.data");
+const INTERNAL_IS_LEAF = Symbol("ScopedStore.isLeaf");
+const INTERNAL_READS = Symbol("ScopedStore.reads");
+const INTERNAL_CHILDREN = Symbol("ScopedStore.children");
+_d = INTERNAL_DATA, _c = INTERNAL_IS_LEAF, _b = INTERNAL_READS, _a = INTERNAL_CHILDREN;
+const _ScopedStore = class _ScopedStore {
+  constructor(data, isLeaf, reads) {
+    /** @internal */
+    __publicField(this, _d);
+    /** @internal */
+    __publicField(this, _c);
+    /** @internal */
+    __publicField(this, _b);
+    /** @internal */
+    __publicField(this, _a);
+    this[INTERNAL_DATA] = data;
+    this[INTERNAL_IS_LEAF] = isLeaf;
+    this[INTERNAL_READS] = reads;
+    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 readEntry(target, prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      has(target, prop) {
+        return typeof prop === "string" ? target.has(prop) : Reflect.has(target, prop);
+      },
+      ownKeys(target) {
+        observeKeys(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 reads = this[INTERNAL_READS];
+    const scope = value && typeof value === "object" && !isLeaf(value) ? value : {};
+    const child = reads ? { ...reads, path: [...reads.path, key] } : void 0;
+    return new _ScopedStore(scope, isLeaf, child);
+  }
+  /**
+   * Check if a key exists in the store.
+   */
+  has(key) {
+    const found = key in this[INTERNAL_DATA];
+    const reads = this[INTERNAL_READS];
+    reads?.observe({ kind: reads.kind, op: "has", path: [...reads.path, key], seen: found });
+    return found;
+  }
+  /**
+   * Get all keys in the store.
+   */
+  keys() {
+    observeKeys(this);
+    return Object.keys(this[INTERNAL_DATA]);
+  }
+};
+let ScopedStore = _ScopedStore;
+function readEntry(target, key) {
+  const value = target[INTERNAL_DATA][key];
+  const reads = target[INTERNAL_READS];
+  if (!reads) return value;
+  const isLeaf = target[INTERNAL_IS_LEAF];
+  const isScope = !!value && typeof value === "object" && !isLeaf(value);
+  const path = [...reads.path, key];
+  reads.observe({ kind: reads.kind, op: "get", path, seen: isScope ? SCOPE : value });
+  if (!isScope || !reads.nested) return value;
+  const children = target[INTERNAL_CHILDREN] ?? (target[INTERNAL_CHILDREN] = /* @__PURE__ */ new Map());
+  let child = children.get(key);
+  if (!child) {
+    child = new ScopedStore(value, isLeaf, { ...reads, path });
+    children.set(key, child);
+  }
+  return child;
+}
+function observeKeys(target) {
+  const reads = target[INTERNAL_READS];
+  reads?.observe({ kind: reads.kind, op: "keys", path: reads.path, seen: Object.keys(target[INTERNAL_DATA]) });
+}
+function createScopedStore(data, isLeaf) {
+  return new ScopedStore(data, isLeaf);
+}
+function observeTextures(map, observe) {
+  const observeKeys2 = () => observe({ kind: "textures", op: "keys", path: [], seen: [...map.keys()] });
+  const observeAll = () => {
+    observeKeys2();
+    for (const [url, texture] of map) observe({ kind: "textures", op: "get", path: [url], seen: texture });
+  };
+  return new Proxy(map, {
+    get(target, prop) {
+      switch (prop) {
+        case "get":
+          return (url) => {
+            const texture = target.get(url);
+            observe({ kind: "textures", op: "get", path: [url], seen: texture });
+            return texture;
+          };
+        case "has":
+          return (url) => {
+            const found = target.has(url);
+            observe({ kind: "textures", op: "has", path: [url], seen: found });
+            return found;
+          };
+        case "size":
+          observeKeys2();
+          return target.size;
+        case "keys":
+          return () => {
+            observeKeys2();
+            return target.keys();
+          };
+        case "values":
+          return () => {
+            observeAll();
+            return target.values();
+          };
+        case "entries":
+        case Symbol.iterator:
+          return () => {
+            observeAll();
+            return target.entries();
+          };
+        case "forEach":
+          return (callback, thisArg) => {
+            observeAll();
+            target.forEach(callback, thisArg);
+          };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function createResourceView(primary, local = primary) {
+  return ((kind) => kind === "textures" ? getTextureView(local) : withStagedOverlay(primary, kind, primary.getState()[kind]));
+}
+function createLazyCreatorState(state, store, options = {}) {
+  const { reads } = options;
+  const view = options.view ?? (store ? createResourceView(store) : void 0);
+  let _uniforms = null;
+  let _nodes = null;
+  let _buffers = null;
+  let _gpuStorage = null;
+  let _textures = null;
+  const read = (kind) => view ? view(kind) : state[kind];
+  const wrap = (kind, isLeaf) => new ScopedStore(
+    read(kind),
+    isLeaf,
+    reads && { ...reads, kind, path: [] }
+  );
+  const properties = {
+    uniforms: {
+      get() {
+        return _uniforms ?? (_uniforms = wrap("uniforms", isUniformNode));
+      }
+    },
+    nodes: {
+      get() {
+        return _nodes ?? (_nodes = wrap("nodes", isTSLNode));
+      }
+    },
+    buffers: {
+      get() {
+        return _buffers ?? (_buffers = wrap("buffers", isBufferLike));
+      }
+    },
+    gpuStorage: {
+      get() {
+        return _gpuStorage ?? (_gpuStorage = wrap("gpuStorage", isStorageLike));
+      }
+    }
+  };
+  if (options.view) {
+    properties.textures = {
+      get() {
+        const textures = options.view("textures");
+        return _textures ?? (_textures = reads ? observeTextures(textures, reads.observe) : textures);
+      }
+    };
+  }
+  return Object.create(state, properties);
+}
+
+function resolvePrimary(local) {
+  return local.getState().primaryStore ?? local;
+}
+function usePrimaryStore() {
+  const local = useStore();
+  const primary = local.getState().primaryStore;
+  return useMemo(() => primary ?? local, [primary, local]);
+}
+function usePrimaryThree(selector = (state) => state, equalityFn) {
+  const local = useStore();
+  const primary = resolvePrimary(local);
+  return primary(selector, equalityFn);
+}
+
+function useCompareMemoize(value, deep) {
+  const ref = useRef(value);
+  const compare = 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.useLayoutEffect : React.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 = 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 = useCallback(
+    (names, targetScope) => removeResourceEntries(store, "uniforms", Array.isArray(names) ? names : [names], targetScope, isUniformNode),
+    [store]
+  );
+  const clearUniforms = useCallback(
+    (targetScope) => clearResourceEntries(store, "uniforms", targetScope, isUniformNode),
+    [store]
+  );
+  const rebuildUniforms = useCallback(
+    (targetScope) => rebuildResource(store, "uniforms", targetScope),
+    [store]
+  );
+  const processedInput = useMemo(() => {
+    let raw = creatorOrScope;
+    if (typeof creatorOrScope === "function") {
+      const wrappedState = createLazyCreatorState(store.getState(), store, { reads: warnMissingReads("useUniforms") });
+      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 = uniform;
+function useUniform(name, value) {
+  const store = usePrimaryStore();
+  const memoizedInput = useCompareMemoize(value === void 0 ? name : { [name]: normalizeValue(value) });
+  const registered = useScopedResource({
+    store,
+    kind: "uniforms",
+    scope: void 0,
+    isLeaf: isUniformNode,
+    input: memoizedInput,
+    create: () => value === void 0 ? {} : { [name]: value },
+    prepare: createNamedUniform,
+    reconcile: (existing2) => {
+      if (value === void 0 || isUniformNode(value)) return;
+      const next = normalizeValue(value);
+      if (isTSLNode(next)) return;
+      existing2.value = next;
+    }
+  });
+  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 normalizeValue(value) {
+  return typeof value === "string" ? new Color(value) : vectorize(value);
+}
+function createNamedUniform(name, value) {
+  let node;
+  if (isUniformNode(value)) {
+    node = value;
+  } else if (isTSLNode(value)) {
+    node = uniformOf(value);
+  } else if (typeof value === "string") {
+    node = uniform(new 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 = useCallback(
+    (names, targetScope) => removeResourceEntries(store, "nodes", Array.isArray(names) ? names : [names], targetScope, isTSLNode),
+    [store]
+  );
+  const clearNodes = useCallback(
+    (targetScope) => clearResourceEntries(store, "nodes", targetScope, isTSLNode),
+    [store]
+  );
+  const rebuildNodes = 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 {};
+      const nodes2 = creatorOrScope(
+        createLazyCreatorState(store.getState(), store, { reads: warnMissingReads("useNodes") })
+      );
+      if (nodes2 == null) {
+        warnOnce(
+          "[useNodes] The creator returned nothing, so nothing was registered. useNodes registers the nodes its creator returns. To put a node onto a Three object (scene.fogNode = ...), use useLocalNodes and return a function that assigns it: it runs after commit and may return a cleanup."
+        );
+        return {};
+      }
+      return nodes2;
+    },
+    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 areDepsEqual(next, prev) {
+  if (next.length !== prev.length) return false;
+  for (let i = 0; i < next.length; i++) if (!Object.is(next[i], prev[i])) return false;
+  return true;
+}
+function useDependencyToken(deps) {
+  const previous = useRef(null);
+  const record = previous.current;
+  if (typeof process !== "undefined" && process.env.NODE_ENV !== "production" && record) {
+    const hadDeps = record.deps !== void 0;
+    const hasDeps = deps !== void 0;
+    if (hadDeps !== hasDeps) {
+      console.warn(
+        `[useLocalNodes] The dependency array was ${hasDeps ? "added" : "omitted"} between renders. Pass an array on every render or on none; the mode must not change for a mounted component.`
+      );
+    } else if (hasDeps && record.deps.length !== deps.length) {
+      console.warn(
+        `[useLocalNodes] The dependency array length changed between renders (${record.deps.length} \u2192 ${deps.length}). Declare a fixed-length list; conditional dependencies belong inside the array as values.`
+      );
+    }
+  }
+  if (deps === void 0) {
+    previous.current = { deps: void 0, token: {} };
+  } else if (!record || record.deps === void 0 || !areDepsEqual(deps, record.deps)) {
+    previous.current = { deps, token: {} };
+  } else if (record.deps !== deps) {
+    previous.current = { deps, token: record.token };
+  }
+  return previous.current.token;
+}
+function useLocalNodes(creator, deps) {
+  const local = useStore();
+  const store = usePrimaryStore();
+  const view = useMemo(() => createResourceView(store, local), [store, local]);
+  const hmrVersion = usePrimaryThree((s) => s._hmrVersion);
+  const depsToken = useDependencyToken(deps);
+  const committedReads = useRef(null);
+  const readsVersion = useRef(0);
+  const getReadsVersion = () => {
+    const tracker2 = committedReads.current;
+    if (tracker2 && !tracker2.stale && isTrackerStale(tracker2, view)) readsVersion.current++;
+    return readsVersion.current;
+  };
+  const subscribe = useCallback(
+    (onChange) => {
+      const unsubscribe = store.subscribe(onChange);
+      if (local === store) return unsubscribe;
+      const unsubscribeLocal = local.subscribe(onChange);
+      return () => {
+        unsubscribe();
+        unsubscribeLocal();
+      };
+    },
+    [store, local]
+  );
+  const resourceVersion = useSyncExternalStore(subscribe, getReadsVersion, getReadsVersion);
+  const evaluation = useMemo(() => {
+    const tracker2 = createReadTracker("useLocalNodes");
+    const reads = { observe: tracker2.observe, nested: true };
+    const value2 = creator(createLazyCreatorState(local.getState(), store, { reads, view }));
+    tracker2.closed = true;
+    return { value: value2, tracker: tracker2 };
+  }, [view, hmrVersion, depsToken, resourceVersion]);
+  const { value, tracker } = evaluation;
+  const installing = typeof value === "function";
+  useModeDiagnostics(value, installing);
+  useIsomorphicLayoutEffect(() => {
+    committedReads.current = tracker;
+    if (!installing) return;
+    tracker.closed = false;
+    let cleanup;
+    try {
+      cleanup = value();
+    } finally {
+      tracker.closed = true;
+    }
+    return typeof cleanup === "function" ? cleanup : void 0;
+  }, [evaluation]);
+  return installing ? void 0 : value;
+}
+function useModeDiagnostics(value, installing) {
+  const previous = useRef(null);
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") return;
+  if (value === void 0 || value === null) {
+    warnOnce(
+      "[useLocalNodes] The creator returned nothing. To put a node onto a Three object (scene.fogNode = ...), build it in the creator and return a function that assigns it: that function runs after commit and may return a cleanup. Assigning inside the creator runs during render, which React may discard or repeat."
+    );
+  }
+  if (previous.current !== null && previous.current !== installing) {
+    warnOnce(
+      "[useLocalNodes] The creator switched between returning a record and returning an install function. Keep one form for a mounted component."
+    );
+  }
+  previous.current = installing;
+}
+
+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 = useCallback(
+    (names, targetScope) => removeResourceEntries(store, "buffers", Array.isArray(names) ? names : [names], targetScope, isBufferLike),
+    [store]
+  );
+  const clearBuffers = useCallback(
+    (targetScope) => clearResourceEntries(store, "buffers", targetScope, isBufferLike),
+    [store]
+  );
+  const rebuildBuffers = useCallback(
+    (targetScope) => rebuildResource(store, "buffers", targetScope),
+    [store]
+  );
+  const disposeBuffers = 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, { reads: warnMissingReads("useBuffers") })
+      );
+    },
+    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 = useCallback(
+    (names, targetScope) => removeResourceEntries(store, "gpuStorage", Array.isArray(names) ? names : [names], targetScope, isStorageLike),
+    [store]
+  );
+  const clearStorage = useCallback(
+    (targetScope) => clearResourceEntries(store, "gpuStorage", targetScope, isStorageLike),
+    [store]
+  );
+  const rebuildStorage = useCallback(
+    (targetScope) => rebuildResource(store, "gpuStorage", targetScope),
+    [store]
+  );
+  const disposeStorageFn = 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, { reads: warnMissingReads("useGPUStorage") })
+      );
+    },
+    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 = useStore();
+  const { scene, camera, renderer, isLegacy } = useThree();
+  const callbacksRanRef = useRef(false);
+  const scenePassCacheRef = useRef(null);
+  const forceScenePassRebuildRef = useRef(false);
+  const mainCBRef = useRef(mainCB);
+  const setupCBRef = useRef(setupCB);
+  mainCBRef.current = mainCB;
+  setupCBRef.current = setupCB;
+  const [rebuildVersion, setRebuildVersion] = useState(0);
+  useEffect(() => {
+    callbacksRanRef.current = false;
+    forceScenePassRebuildRef.current = true;
+  }, []);
+  const clearPasses = useCallback(() => {
+    store.setState({ passes: {} });
+  }, [store]);
+  const reset = 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 = useCallback(() => {
+    callbacksRanRef.current = false;
+    forceScenePassRebuildRef.current = true;
+    setRebuildVersion((v) => v + 1);
+  }, []);
+  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.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 = 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((s) => s.passes) ?? NO_PASSES;
+  const renderPipeline = 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();
+
+export { configureTSL, createScopedStore, rebuildAllBuffers, rebuildAllNodes, rebuildAllStorage, rebuildAllUniforms, useBuffers, useGPUStorage, useLocalNodes, useNodes, useRenderPipeline, useUniform, useUniforms };