# Three Blocks Full Agent Reference Generated from the same typed contracts as the human documentation for Three Blocks 0.10.0. ## AI Usage Policy This documentation is published so AI assistants can help people use the public `three-blocks` API: - Public documentation may be retrieved and summarized to help a person use the documented API. - Documentation permission does not change the PolyForm Noncommercial 1.0.0 license on implementation code. That license and applicable law control use of npm `dist`, examples, and source. - Text-and-data-mining rights are reserved to the extent permitted by law (EU Directive 2019/790 Art. 4(3); see `/ai.txt`, `/.well-known/tdmrep.json`, and the `tdm-reservation` response header). - The accepted commercial agreement separately restricts training or evaluating models on implementation source and proprietary Pro Tools. ## License and Pro boundary - The `three-blocks` runtime, `@three-blocks/devtools`, `create-three-blocks-starter`, and shipped template source use PolyForm Noncommercial 1.0.0. - Personal and noncommercial projects are free. Pro grants each Project started during an active period a lifetime commercial license for versions released during that period. Covered Projects and Pro Tool versions obtained while active may keep running locally and offline after cancellation. New commercial Projects, later versions, and Pro Tool downloads or updates require an active seat. Covered versions have no runtime gate. - New Pro Tool downloads and updates use `npx three-blocks login`; installed covered tools run locally. Public runtime imports, starter creation, and generated application execution do not check an account. ## Human-authored guides ### ActiveFrame Video Canonical: https://threejs-blocks.com/docs/blocks/active-frame-video Use ActiveFrame when code needs exact or weighted random access to decoded frames instead of ordinary linear playback. ## When to choose ActiveFrame Video Keep color space, dimensions, codec, slot count, and readiness explicit; coalesce pointer-driven selection before decoding. ## Ship ActiveFrame Video safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Baked Motion Canonical: https://threejs-blocks.com/docs/blocks/baked-motion Preserve an approved rendered look when interaction stays inside an authored timeline, rotation, or tilt grid. Baked Motion owns decoded media and its GPU sampling resources; the application owns the poster, semantics, input, and visibility policy. ## When to choose Baked Motion Keep a useful `` visible before constructing `BakedMotion`. Hide it only after `ready` resolves for the first sample, or after `frameReady` resolves if the application requested a different sample during startup. Any failure or reduced-motion choice leaves the poster visible. `ready` is not a manifest-download milestone. It resolves after the selected rendition's required decoder group has admitted and a valid first sample has reached the texture slots. It rejects with `BakedMotionError`, never with a successful but blank mesh. ```html
Product in its composed rest pose

Loading interactive view

``` ```js import { BakedMotion, BakedMotionError, } from "three-blocks/baked-motion"; const stage = document.querySelector("#motion-stage"); const poster = document.querySelector("#motion-poster"); const status = document.querySelector("#motion-status"); const reducedMotion = matchMedia("(prefers-reduced-motion: reduce)"); let motion = null; if (reducedMotion.matches) { status.textContent = "Static view — reduced motion"; } else { motion = new BakedMotion("/product/shot.utsbv/manifest.json", { renderer, strategy: "stream", rendition: "auto", maxRenditionWidth: 2048, }); try { await motion.ready; scene.add(motion.mesh); // If startup code calls setTime(), setPointer(), or setView(), await the // frameReady promise created by that request before revealing the canvas. await motion.frameReady; renderer.render(scene, camera); poster.hidden = true; status.textContent = "Interactive view ready"; } catch (error) { const code = error instanceof BakedMotionError ? error.code : "unavailable"; status.textContent = `Static fallback — ${code}`; // Keep poster.hidden === false. } } ``` The host should catch `ready`; the runtime also passively observes the promise so a deliberately poster-only integration does not create an unhandled page error. Do not add `motion.mesh` as an optimistic placeholder and do not remove the poster in a `finally` block. ## State, errors, and local diagnostics `motion.state` is one of `loading`, `admitting`, `ready`, `suspended`, `failed`, or `disposed`. Application decisions should branch on `BakedMotionError.code`, not on human-readable messages: - delivery, asset, and publishing failures: `manifest-invalid`, `network`, and `integrity`; - device or resource outcomes: `webcodecs-unavailable`, `decoder-unsupported`, `decoder-capacity`, `decoder-stalled`, `gpu-upload`, and `resource-budget`; - lifecycle outcomes: `aborted` and `disposed`. `getDiagnostics()` returns a deeply immutable, point-in-time snapshot. It is safe to render in a local support panel. Keep the normal UI concise—state, selected rendition, delivery mode, and error code—then put decoder attempts and byte counters behind a details control. Diagnostics are local debugging data; do not transmit decoder or hardware fingerprints without a separate product and privacy decision. ```js function showLocalDiagnostics(error = null) { const diagnostics = error instanceof BakedMotionError ? error.diagnostics : motion?.getDiagnostics(); diagnosticSummary.textContent = diagnostics ? [ diagnostics.state, diagnostics.selectedRendition ?? "no rendition", diagnostics.network.mode ?? "no delivery", diagnostics.terminalErrorCode, ].filter(Boolean).join(" · ") : "Baked Motion unavailable"; diagnosticDetails.textContent = diagnostics ? JSON.stringify(diagnostics, null, 2) : ""; } ``` Diagnostics distinguish verified delivery bytes from admission probes. Use `network.verifiedBytes`, `network.probeBytes`, `network.cacheBytes`, `attemptedRenditions`, `selectedRendition`, and `decoderAttempts` when explaining a fallback. Do not infer hardware decoding from the requested acceleration preference. Version 2 fetches each selected ActiveFrame resource once, verifies its declared byte length and whole-file SHA-256, then keeps the encoded buffer available to WebCodecs. `maxFullFileBytes` defaults to 256 MiB per resource and rejects a larger declared or received body before decoder admission. Inspect `network.requestCount`, `requestedBytes`, `verifiedBytes`, and `cacheBytes`, and confirm encoded residency returns to zero after disposal. Format 2 tilt packages can also carry a package-wide `resources.proxy` field. The runtime fetches and authenticates each compact proxy ActiveFrame resource once, keeps the complete view field resident across suspension, and forward-warps it at the current pointer pose while full-resolution views refine the result. `decodedCacheBudget` controls the GPU LRU used for revisited full-resolution views (128 MiB desktop, 48 MiB mobile by default). Inspect `diagnostics.residency.proxy`, `.cache`, and `.fresh` to distinguish a complete smooth-soft presentation from full-resolution residency. `proxyOnly: true` is available for the certified mobile floor and intentional low-bandwidth presentations; it requires an authored proxy. For upload-path attribution, inspect `diagnostics.uploads.albedo` and `diagnostics.uploads.depth`. Each track reports per-channel GPU-luma upload counts plus CPU `VideoFrame.copyTo()` calls, total time, and maximum time. A supported WebGPU luma path should increase `gpuLumaUploads` while the matching CPU counters remain zero; the CPU fallback remains observable instead of being reported as GPU work. ## Visibility and decoder ownership Suspend when the document is hidden or the experience is offscreen. Suspension releases decoder sessions while retaining the last valid textures. Resume re-admits the group and presents the latest requested parameters into those same textures. ```js let inViewport = true; async function synchronizeVisibility() { if (!motion || motion.state === "failed" || motion.state === "disposed") return; if (document.hidden || !inViewport) { motion.suspend(); showLocalDiagnostics(); return; } try { await motion.resume(); showLocalDiagnostics(); } catch (error) { poster.hidden = false; showLocalDiagnostics(error); } } document.addEventListener("visibilitychange", synchronizeVisibility); const visibility = new IntersectionObserver(([entry]) => { inViewport = entry?.isIntersecting ?? true; void synchronizeVisibility(); }, { threshold: 0.01 }); visibility.observe(stage); ``` On unmount, disconnect the observer and listener, stop the render loop, then call `motion.dispose()`. `suspend()` is a temporary park, not a substitute for disposal. ## Reduced-motion policy Read `prefers-reduced-motion` before starting WebGPU, fetching a manifest, or acquiring decoders. The conservative product policy is to keep the authored poster and skip Baked Motion entirely. If the preference changes to `reduce` after startup, reveal the poster and suspend or dispose the instance. Do not silently replace autonomous motion with pointer-driven motion; if the product offers an explicit “Enable interactive view” control, keep that choice in the application layer. ## Rendition policy Use `rendition: "auto"` for normal delivery. Auto mode tries verified, device-eligible renditions from highest to lowest and records every decision in diagnostics. Set `maxRenditionWidth` from the product's quality and resource budget when a device should not attempt the authored maximum. Decoder or resource failures may move to the next verified rendition; network integrity, length, and hash failures are terminal and must not be treated as a reason to trust a different file. An explicit rendition ID is a certification and debugging tool. It disables quality fallback: that exact rendition presents or rejects with a typed error. Never label an automatic fallback as the forced quality in analytics or UI. Read `selectedRendition` after readiness. Version 1 packages remain compatible through the same full-file path. Prefer version 2 for verified resources and rendition selection. ## Host complete ActiveFrame resources The origin and every CDN layer must preserve each `.af` body exactly. Baked Motion uses one ordinary GET per selected albedo or depth resource, not a request per frame or GOP. For each `.af` resource: - return `200 OK` and an accurate `Content-Length`; - do not gzip, Brotli-compress, resize, optimize, or otherwise transform `.af` bodies. Omit `Content-Encoding` (or serve the identity representation); - use revisioned immutable URLs before sending a long-lived `Cache-Control: public, max-age=31536000, immutable` policy. For cross-origin delivery, return the appropriate `Access-Control-Allow-Origin` value: ```http Access-Control-Allow-Origin: https://shop.example ``` Verify the deployed CDN, not only the origin or a `HEAD` response: ```text curl -sS -D - -o /dev/null \ -H 'Origin: https://shop.example' \ https://media.example/product/renditions/2048/albedo.af ``` Expect `200`, the manifest's exact byte length, the allowed origin, and no `Content-Encoding`. The runtime also enforces `maxFullFileBytes` and verifies the complete SHA-256 before any media bytes reach WebCodecs. ## Ship Baked Motion safely - Keep the poster through the first requested `frameReady` and every failure. - Exercise reduced motion before WebGPU initialization and after a live start. - Verify suspend/resume across document visibility and viewport changes. - Test automatic and forced rendition behavior with local diagnostics visible. - Probe the deployed `.af` URL for one complete response with the declared length and an untransformed identity body. - Dispose observers, listeners, motion, and renderer in ownership order. ### Boids Canonical: https://threejs-blocks.com/docs/blocks/boids Use GPU flocking for many agents whose steering, domain, constraints, and interaction must stay responsive. ## When to choose boids Scale steering to domain and time step, measure the grid crossover, cap hidden-tab deltas, and use simple dense rendering. ## Ship a boids scene safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Compute foundations Canonical: https://threejs-blocks.com/docs/blocks/compute-foundations Use scans, sorts, batching, and bounded readback underneath product blocks needing deterministic GPU data flow. ## When to choose compute foundations Fix capacity and typed layouts up front, run producers before consumers, and keep diagnostic readback asynchronous. ## Validate compute cost in the target scene Profile the final element count, pass order, workgroup shape, and readback frequency on representative target devices. Keep asynchronous diagnostics outside the frame loop and provide a higher-level or CPU fallback where WebGPU is unavailable. ## Ship GPU compute foundations safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Core TSL effects Canonical: https://threejs-blocks.com/docs/blocks/core-tsl-effects Compose reusable material and post effects from explicit node inputs, coordinate spaces, and render stages. ## When to choose core TSL effects Keep graphs stable, animate uniforms, resize screen-space inputs, and expose samples or kernel radius as measured tiers. ## Ship core TSL effects safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Gaussian Splats Canonical: https://threejs-blocks.com/docs/blocks/gaussian-splats Use splats when capture preserves detail that a clean production mesh would be expensive to rebuild. ## When to choose Gaussian splats Measure visible density, sorting, overdraw, cache eviction, and upload peaks on target devices; retain a poster or mesh fallback. ## Ship Gaussian splats safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### GPU Interaction Canonical: https://threejs-blocks.com/docs/blocks/gpu-interaction Give multiple GPU systems one normalized source, collider, authority, and frame-order contract. ## When to choose GPU interaction Validate capacities and device limits, step interaction before every consumer, and keep metrics readback out of the hot path. ## Ship GPU interaction safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Pristine grid Canonical: https://threejs-blocks.com/docs/blocks/grid-pristine `GridPristine` adds an infinite-looking reference floor with independently styled major and minor world-space grid layers. ## Add a scale reference to editors and staged scenes Use the grid for editors, simulation previews, product staging, and technical scenes that need a stable scale reference. Prefer authored floor geometry when the ground must carry texture detail, collision, or irregular boundaries. ## Add, update, and dispose the grid Create the grid, add it to the scene, and update its public uniform values when the presentation changes. Call `dispose()` when the scene is removed; it releases the owned geometry, material, and optional GUI folder. ## Tune the grid for the camera Choose cell sizes and line widths in the same world units as the scene. Check both near and distant camera positions at the target DPR so minor lines do not collapse into shimmer. ## Check grid legibility before shipping - Confirm the public `three-blocks/grid-pristine` import shown on this page. - Run the compile-gated example at the target camera range and DPR. - Verify both grid layers remain legible against the approved background. ### Indirect Batching Canonical: https://threejs-blocks.com/docs/blocks/indirect-batching Pack many geometries and instances behind one batch contract when individual scene objects become the bottleneck. ## Choose the primitive that owns the workload | Workload | Recommended primitive | |---|---| | One or a few homogeneous, inexpensive, mostly visible sets | Three.js `InstancedMesh` | | CPU-owned heterogeneous objects where editability matters | Three.js `BatchedMesh` | | GPU-owned, heterogeneous, visibility-heavy populations | Three Blocks `IndirectBatchedMesh` with Three Blocks GPU culling as a specialized/experimental option | | Homogeneous GPU-owned population needing per-instance culling | Three.js `InstancedMesh` with Three Blocks `ComputeInstanceCulling` | Indirect rendering does not mean one hardware draw and is not automatically faster. Its value is that GPU-produced visibility can control indirect instance ranges without a CPU readback while heterogeneous geometry and source-instance identity remain in one batch contract. Use [The Brick Room](/examples/webgpu_indirect_batchedmesh_visibility) to inspect a complete GPU-owned chain: granular MLS-MPM drives 131,072 tumbling pieces, a frame-level pose pass selects three LOD tiers for eight archetypes, and the internal culler compacts survivors across 24 indirect commands in one render item. Use [GPU-Driven City](/examples/webgpu_indirect_batchedmesh) for a production-style integration of GPU-authored transforms, an endless ring, heterogeneous geometry, and textured materials. ## Choose indirect ownership for the final workload The shared-indirect path avoids a CPU readback when GPU-produced visibility must control heterogeneous instance ranges. Its batching, visibility, and indirect-command work can still cost more than a simpler path in sparse scenes. Choose it for the ownership boundary your scene needs, then validate the finished workload on its target devices. ## When to choose indirect batching Reserve honest capacities, mutate in bulk, keep culling order explicit, and dispose packed storage once producers stop. ## Ship indirect batching safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Instance Culling Canonical: https://threejs-blocks.com/docs/blocks/instance-culling Cull a GPU-owned population before drawing when the authored count is much larger than the visible set. ## When to choose instance culling Verify conservative bounds, update camera uniforms in the same frame, and resolve survivor IDs back to source data. ## Ship instance culling safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Material Point Method Canonical: https://threejs-blocks.com/docs/blocks/mpm Use `MPMSolver` when a custom particle-grid simulation needs material, force, collider, diagnostic, or post-pass control beyond the higher-level Water product. ## Choose the material contract Start with `MPMFluidModel` for a pressure-and-viscosity fluid, `MPMGranularModel` for Coulomb-capped friction without extra particle storage, or `MPMElasticModel` for fixed-corotated elastic deformation. A custom `MPMMaterialModel` can add particle fields and implement initialization, stress, and deformation updates without replacing the solver lifecycle. ## Seed, step, and dispose the solver Create the solver after WebGPU renderer initialization, seed it once with a TSL initializer, and call `step(renderer, delta)` before dependent GPU work. The solver exposes stable particle and grid storage for a caller-owned impostor, surface reconstruction, probe, or other render mirror. Dispose those consumers before calling `solver.dispose()`. ## Calibrate the material, grid, and time step Calibrate material constants, grid scale, and time step as one system before adding sorting, CFL substeps, diagnostics, or custom hooks. Keep state on the GPU and limit readback to diagnostics or explicit capture workflows. ## Verify the MPM simulation before shipping - Confirm the public `three-blocks/mpm` import shown on this page. - Run the compile-gated seed/step example on the minimum supported WebGPU tier. - Verify the render mirror consumes the same-frame particle state. - Ship a static or simpler authored fallback for unsupported devices. ### MSDF Text Canonical: https://threejs-blocks.com/docs/blocks/msdf-text Bake a known production charset so spatial and screen-space typography has predictable atlas, layout, and batching cost. ## Prepare the atlas Run `npx three-blocks text generate` to create the atlas, metrics, configured browser-font copy, and receipt. The [Devtools text workflow](/docs/tools/devtools#generate-text-atlases-before-runtime) explains the configuration, public output routes, Vite watcher wiring, and release checks. ## When to choose MSDF text Verify every locale, share atlas state, avoid per-frame layout, and retain semantic text where the visual copy carries meaning. ## Ship MSDF text safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Object Animation Video Canonical: https://threejs-blocks.com/docs/blocks/object-animation-video Use OAV when separately addressable rigid parts need compact authored transform playback while geometry, materials, lighting, and camera response remain live. ## Package format OAV version 2 is the current public schema. It contains one exact indexed-meshopt UTSBM transform track and creates no `VideoDecoder` or `VideoFrame` for transforms. The track ships as one block-indexed `.utsbm` asset, fetched once and streamed progressively; it is transport, not a GPU format. The runtime reconstructs typed transform values, applies them to objects or instance matrices, and lets Three.js upload changed instance or batch buffers. Inspect `getDiagnostics()` for block-decoder state and bounded two-frame numerical residency. ## When to choose Object Animation Video Bind in strict mode during integration, preserve stable names and parents, and publish the manifest plus every selected track under one immutable URL. ## Ship Object Animation Video safely - Confirm the public import and version shown on this page. - Verify all 12 affine components at the declared 12-bit quantization boundary. - Confirm playback creates no numerical video decoder and retains no more than two presented quantized frames. - Preserve a useful static or simpler fallback before live GPU work. ### Position-Based Fluids Canonical: https://threejs-blocks.com/docs/blocks/pbf Choose PBF when stable incompressibility and iteration-based quality matter more than force-driven pressure behavior. ## When to choose Position-Based Fluids Calibrate radius, spacing, density, iterations, and time step together; tier simulation and particle rendering as one budget. ## Ship Position-Based Fluids safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Runtime SDF Text Canonical: https://threejs-blocks.com/docs/blocks/runtime-sdf-text This experimental block supports applications whose user or remote content can introduce glyphs after deployment. Its API may evolve while the runtime text path is refined. Use [MSDF Text](/docs/blocks/msdf-text) for new work when the required character set can be baked ahead of time. Choose Runtime SDF Text only when genuinely unknown glyphs require its runtime atlas and worker pipeline. ## When to choose runtime SDF text Import `Text` and `BatchedText` only from `three-blocks/experimental/runtime-sdf-text`. Bound fonts and caches, await synchronization, debounce layout changes, and dispose route-owned workers and text objects. ## Ship runtime SDF text safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### SDF and raymarching Canonical: https://threejs-blocks.com/docs/blocks/sdf-raymarching Use a sampled signed field for many cheap GPU queries or a volume sharing one bounds and coordinate contract. ## When to choose SDF raymarching Preserve thin features with explicit resolution and margin, avoid per-frame regeneration, and separate field from screen cost. ## Polished translucent surfaces `RayMarchSDFNodeMaterial` keeps its legacy opaque and homogeneous paths when the advanced controls stay at their zero defaults. Turn on the analytic studio, soft scatter, refraction, field-local clouds or veins, dual-lobe finish, and filmic output only when the product needs a polished stone or gem presentation. The material measures view and light paths through the generated field; it does not require a separate surface mesh or an environment texture. Use `quality` as the single performance escape hatch. Higher tiers restore work in this order: | Tier | Interior noise | Exit dispersion | Cone-light paths | | --- | --- | --- | --- | | `0` Economy | 2 layers | Off | 1 | | `1` Low | 3 layers | Off | 1 | | `2` Balanced | 3 layers | On | 1 | | `3` High | 3 layers | On | 2 | | `4` Full | 3 layers | On | 3 | Profile the full-screen raymarch at the final device-pixel ratio. Lower the quality tier before reducing SDF resolution: that preserves the silhouette and thin features while folding optional medium and lighting work. ## Ship SDF raymarching safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Verify the selected quality tier at the shipping viewport and device-pixel ratio. - Preserve a useful static or simpler fallback before live GPU work. ### Smoke Canonical: https://threejs-blocks.com/docs/blocks/smoke Use a volume simulation when atmosphere must occupy depth, react to forces, and composite with scene geometry. ## When to choose smoke Treat grid resolution, pressure work, turbulence, caches, and compositor resolution as one named quality ladder. ## Ship a smoke scene safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Smoothed Particle Hydrodynamics Canonical: https://threejs-blocks.com/docs/blocks/sph Choose SPH when pressure and viscosity forces are the material controls the project needs. ## When to choose Smoothed Particle Hydrodynamics Calibrate mass, smoothing radius, rest density, pressure, and time step as one set before raising count or visual quality. ## Ship an SPH simulation safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Sphere impostors Canonical: https://threejs-blocks.com/docs/blocks/sphere-impostors Trade repeated sphere vertices for analytic fragment shading when particle count is high and projected size stays bounded. ## When to choose sphere impostors Compare geometry and impostors at the target DPR and overdraw. Verify analytic depth, edges, lighting, and the geometry fallback. ## Validate sphere impostors in the target scene Test the final count, projected radius, overlap, renderer size, and DPR on representative target devices. Switch to hardware geometry when close or overlapping impostors move too much work into fragment shading. ## Ship sphere impostors safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Surface Sampling Canonical: https://threejs-blocks.com/docs/blocks/surface-sampling Keep large sampled populations GPU-resident from an art-directed source mesh into culling and rendering. ## When to choose surface sampling Use the static sampler unless vertices truly change, initialize dynamic storage from source positions, and never read back per frame. ## Ship surface sampling safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Transmission Canonical: https://threejs-blocks.com/docs/blocks/transmission `MeshTransmissionNodeMaterial` gives a product surface controllable refractive depth while keeping the material inside the Three.js node-material pipeline. ![A refractive box containing a particle simulation.](/examples/screenshots/webgpu_material_transmission.avif) ## Choose live refraction for interactive surfaces Use Transmission when the object must keep live geometry, lighting, and camera movement and the refractive surface is part of the interaction. Choose a baked render when the approved material response matters more than arbitrary live viewpoints. Choose a simpler physical material when thin glass is enough and a second sample path would not be visible. ## Install the Transmission material ```sh bun add three three-blocks ``` Import Three.js from `three/webgpu` and `MeshTransmissionNodeMaterial` from `three-blocks/transmission`. Initialize `WebGPURenderer` before creating the GPU resources used by the scene. ## Build a complete refractive scene The compile-gated example above and the [Start scene](/docs/start) contain the complete renderer, camera, material, resize, frame-loop, and disposal path. Keep that lifecycle intact when moving the material into a larger product scene. ## Create, resize, and dispose Transmission Create the material after renderer initialization. Update only the parameters that truly respond to the experience; object transforms can stay in the normal frame loop. Resize the renderer and camera together. Stop the animation loop, then dispose both geometry and material when the scene leaves the page. ## Control the state behind the refracted result The CPU owns material configuration, object transforms, and lifecycle. Three.js owns the render targets and GPU resources behind the node material. The visible output depends on scene color behind the refractive surface, so an empty or flat background can make a correct material look broken. ## Tune transmission, thickness, and absorption - `transmission` controls how much light passes through the surface. - `thickness` describes the distance light travels inside the object. - `roughness` trades sharp refraction for a broader response. - Attenuation color and distance shape absorption through thicker regions. Start with the physical dimensions of the model. Art-directed noise or chromatic treatments should come after the base thickness and lighting read correctly. ## Budget refractive sampling cost Cost rises with covered pixels, sampling quality, background complexity, DPR, and the number of overlapping transmissive surfaces. Reduce renderer resolution or material quality before reducing geometric detail that defines the silhouette. Check the finished composition at its target viewport and DPR. If overlapping surfaces exceed the frame budget, lower sampling quality or renderer resolution before changing the silhouette. ## Check browser and package support Transmission is a stable library-runtime block for WebGPU browser scenes. It does not require a Pro authoring tool. Verify support with the shipping Three Blocks version and the compatible Three.js range declared by the package before shipping a fallback. ## Judge refraction against the final background Judge the material against the actual approved background and environment. A studio turntable that looks convincing over an HDR environment can lose all depth over a flat campaign color. Keep the restrained physical response as a named quality tier, then add noise or dispersion only where the shot proves their value. ## Explore Transmission examples - [Material Transmission example](/examples/webgpu_material_transmission) - [Your first Three Blocks scene](/docs/start) ## Compare related material blocks - [Baked Motion](/docs/blocks/baked-motion) preserves an approved rendered material when camera freedom can be constrained. - [Core TSL effects](/docs/blocks/core-tsl-effects) add art-directed nodes without changing the representation of the object. ## Read the MeshTransmissionNodeMaterial API The exhaustive public contract lives on the [`MeshTransmissionNodeMaterial` API page](/docs/api/MeshTransmissionNodeMaterial), including its constructor, public members, entry-point import, JSDoc, status, and linked examples. This page keeps configuration advice and production trade-offs separate from that generated table. ### Vertex Animation Video Canonical: https://threejs-blocks.com/docs/blocks/vertex-animation-video Use VAV when topology stays stable but vertices deform and the browser must retain live material and camera response. ## Package format VAV version 2 is the current public schema. Numerical geometry and per-vertex appearance are exact indexed-meshopt UTSBM tracks and create no `VideoDecoder` or `VideoFrame`. UV-space appearance remains visual media and keeps its media-decoder behavior. Each track ships as one block-indexed `.utsbm` asset, fetched once and streamed progressively; it is transport, not a GPU format. The runtime reconstructs typed lanes, copies them into two persistent R8 `DataTexture` atlases, and marks the changed slot for upload. The vertex shader samples and interpolates those two textures. Inspect `getDiagnostics()` for numerical decoder state, UV decoder count, and the bounded presented slots. ## When to choose Vertex Animation Video Verify topology, vertex order, geometry and appearance timing, quantization bounds, decoded-slot limits, and the selected appearance tier. Publish related tracks and `base.bin` as one immutable package. ## Ship Vertex Animation Video safely - Confirm the public import and version shown on this page. - Verify positions, normals, materials, bounds, and interpolation against rendered references. - Confirm numerical tracks create no video decoder; count UV-media decoders separately. - Preserve a useful static or simpler fallback before live GPU work. ### Water Canonical: https://threejs-blocks.com/docs/blocks/water Use Water when particle and grid motion, reconstructed surface, foam, and interaction must behave as one system. ## When to choose Water Tune domain and solver before surface polish; step simulation before reconstruction and tier compute and screen cost together. ## Validate Water on target devices Test particle capacity, grid resolution, reconstruction, foam, and raymarch resolution together on representative target devices. Reduce the named tier or switch to the shader-only fallback when the complete scene exceeds its frame budget. ## Ship Water safely - Confirm the public import and version shown on this page. - Run the compile-gated example and linked project fixture. - Preserve a useful static or simpler fallback before live GPU work. ### Baked Motion versus VAV versus OAV Canonical: https://threejs-blocks.com/docs/concepts/baked-motion-versus-vav-oav These motion products preserve different freedoms after the browser loads. ## Choose a motion format by what stays live Use approved pixels for Baked Motion, deforming geometry for VAV, and rigid transforms for OAV. | Product | What remains authored | What remains live | |---|---|---| | Baked Motion | Rendered views, optional depth, and captured appearance | Timeline or pose sampling inside the captured camera domain | | Deforming Mesh Motion (VAV) | Stable-topology vertex motion and optional appearance | Mesh material, lighting, camera, and scene composition | | Object Motion (OAV) | Named rigid-object affine transforms and hierarchy | Geometry, materials, lighting, camera, per-object binding, and culling | Three Blocks selects visual media tracks for decoded images that remain on the GPU and exact numerical tracks for transforms or geometry. Advanced format references document those transports separately; neither transport name should lead the product decision. ## Diagnose motion format mismatches Trace the product package, media decoder or binary byte-range source, CPU reconstruction, upload, GPU consumer, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Compute before render Canonical: https://threejs-blocks.com/docs/concepts/compute-before-render A render pass can read stale storage when simulation, sampling, or culling runs too late. ## Run compute before rendering Update input, dispatch compute, update indirect data, and only then render. ## Fix stale GPU data Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Storage buffers and GPU ownership Canonical: https://threejs-blocks.com/docs/concepts/gpu-ownership Repeated CPU readback and upload destroys the scale GPU-resident blocks are meant to provide. ## Keep storage buffers on the GPU Name one owner, writer, readers, lifetime, and disposal path for every shared resource. ## Fix CPU and GPU ownership conflicts Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ## Follow one GPU-owned chain [The Brick Room](/examples/webgpu_indirect_batchedmesh_visibility) keeps simulation, tumbling transforms, geometry LOD, visibility, and drawing on the GPU. Granular MLS-MPM updates one particle per released toy brick; one post pass writes quaternion-integrated matrices and per-frame geometry IDs into `IndirectBatchedMesh`, then the internal culler re-buckets survivors across 24 indirect commands. Pointer and BUILD interactions change uniforms, while a throttled all-command readback supplies evidence only to the HUD. ### Hardware geometry versus sphere impostors Canonical: https://threejs-blocks.com/docs/concepts/hardware-geometry-versus-sphere-impostors Dense spheres can be vertex-bound or move too much work into fragment shading and overdraw. ## Choose geometry or sphere impostors Measure both at target projected size, overlap, renderer size, and DPR. ## Test sphere rendering on target devices Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ## Compare both paths in the target scene Test geometry and impostors on representative target devices with the final renderer size, DPR, particle count, projected radius, and overlap. Choose geometry for large close spheres, and use impostors only while their fragment and depth cost stays within the scene's frame budget. ### Lifecycle and disposal Canonical: https://threejs-blocks.com/docs/concepts/lifecycle-and-disposal GPU memory, decoders, requests, workers, listeners, and loops outlive routes unless ownership is explicit. Suspension and disposal solve different parts of that problem. ## Give every resource one owner Stop producers before disposing consumers and shared resources. Suspend only when an experience may return; dispose when its owner is gone. ## Suspend media-backed blocks Hidden or offscreen Baked Motion can release its decoder group without discarding the last valid texture contents. `suspend()` is idempotent and immediate. `resume()` asynchronously re-admits the required group and restores the newest requested sample. Catch resume errors and restore the host's poster; capacity and capability can change while an experience is parked. Keep visibility policy in the application. Combine `document.hidden` with an `IntersectionObserver`, disconnect both on unmount, and avoid resuming every inactive tab or carousel item at once. Reduced-motion selection should normally skip construction entirely. ## Dispose terminal owners On route or component teardown: 1. stop animation and scheduling loops; 2. disconnect visibility, resize, and input producers; 3. abort or dispose media owners such as Baked Motion; 4. dispose application-owned geometry, material, renderer, and DOM overlays. Disposal may race manifest fetch, range fetch, decoder admission, sample upload, or resume. Pending milestones reject with typed lifecycle outcomes; observe promises intentionally rather than leaving them as page errors. Calling `suspend()` before `dispose()` is unnecessary. ## Dispose resources when their owner leaves Trace the owner, input, request, decoder lease, GPU work, consumer, fallback, suspension, and disposal path in that order. After teardown, decoder, request, frame, timer, and owned GPU counts should all return to zero. A retained shared cache entry must still have an explicit page-cache owner and byte ceiling. ### MSDF versus runtime SDF text Canonical: https://threejs-blocks.com/docs/concepts/msdf-versus-runtime-sdf-text Baked and runtime SDF text move charset, startup, worker, and cache costs to different stages. ## Choose when to build the text atlas Bake known copy with the stable MSDF Text block. Use the experimental Runtime SDF Text path only for genuinely unknown glyphs that cannot be included in an atlas before deployment. ## Fix text startup and caching problems Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Performance ladders and mobile fallbacks Canonical: https://threejs-blocks.com/docs/concepts/performance-ladders One setting cannot cover desktop headroom, mobile thermals, reduced motion, and missing WebGPU. ## Set quality tiers before shipping Detect capability, select a named tier, measure the whole frame, and retain a useful fallback. ## Test every quality tier and fallback Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ## Validate the ladder on target devices Test each named tier with the final scene, renderer size, device pixel ratio (DPR), interaction, and fallback enabled. Use representative target devices to set project limits, and lower the tier when the whole frame exceeds its budget. ### Precompiled shaders Canonical: https://threejs-blocks.com/docs/concepts/precompiled-shaders Three Blocks prepares your registered shaders during development and saves the result beside your project. When a visitor opens the scene, it reuses that result instead of repeating the Three Shading Language (TSL) build. Time, pointer, color, light, and other live values reconnect and continue to update. ## Capture from the development overlay After the shader-relevant parts of the current scene settle, open the Three Blocks overlay. It reports **Shader capture required** and shows the live build count and the NodeBuilder elapsed time. Click **Capture shaders**. The page reloads once with capture mode active. The same scene runs normally while a post-build hook records its generated shaders and replay data. The overlay reports **Building N/N**, **Settling…**, and **Writing…**; keep the tab visible while it captures. If the tab becomes hidden, capture pauses and explains why instead of timing out. You can cancel at any point. Three Blocks validates the result against the semantic inputs snapshotted before the reload, then writes it under `.three-blocks/shaders` with `meta.json` last. The page reloads with the fresh result and shows **shaders captured**, followed by **Shaders precompiled** once hydration succeeds. To test this in the repository gallery, start one source-backed example: ```sh bun run dev webgpu_simulation_boids_3d ``` Open `/examples/webgpu_simulation_boids_3d`, edit that example or a shared shader input, refresh the example, then open the overlay in the example frame and click **Capture shaders**. Keep the tab visible through the capture reload. The current scene returns as **Shaders precompiled**; other stale gallery scenes remain unchanged. Run `bun run examples:optimize` when you need the complete gallery matrix and screenshots refreshed. One tab captures its current configured scene. If the overlay reports other stale scenes, or you need an isolated batch or continuous integration (CI) capture, use the command-line fallback: ```sh npx three-blocks shaders capture ``` The CLI opens every registered route for each configured renderer backend and uses the same capture hook and validation. The default is WebGPU; set `backend` to `webgl` or `both` in `three-blocks.shaders.json` when the release also targets Three's WebGL fallback. Commit the generated files so production can load them without needing a graphics processor during deployment. When no shader config exists, the command creates a default `/` route. It also writes `public/three-blocks/shaders/..json`; the existing `registerDevtools({ renderer })` line discovers and installs it. Vite supplies the golden-path transform. For webpack/Next, Rollup, and esbuild, capture detects the project, previews the required adapter diff for consent, then starts or builds the app itself. Static and attached browser drivers remain explicit overrides. The [Devtools compatibility guide](/docs/tools/devtools#use-the-threejs-r185-compatibility-layer) explains the version-gated r185 transform used by every adapter. The transform supplies the capture and hydration seams in memory without changing `node_modules`. Use the bare command as the fast, no-browser safety check. It exits non-zero and prints the exact recovery command when any configured scene is not fresh: ```sh npx three-blocks shaders ``` ## Read the TSL build timing Build timing belongs to the current scene and capture. In the starter project's latest local capture, precompilation removed about 30 ms of TSL build work from the visitor's first load. The development overlay presents that project-specific value as **NodeBuilder time saved**. When timing was not recorded, the overlay says **Capture estimate unavailable**. A shader-relevant edit makes old timing unavailable along with the old capture; Three Blocks does not carry the number across changed shader inputs. ## Keep live values live Precompilation saves shader setup, not the state of the finished scene. Continue to update time, pointer, color, light, transforms, and other live inputs as usual. The saved shader reconnects to the objects your app creates at runtime. One registration key represents one shader shape. The default workflow assigns deterministic scene-scoped keys when the app does not provide them. Explicit semantic keys remain useful for complex matrices and diagnostics. Capture every route and state that can change compile-time branches such as lights, fog, tone mapping, and material defines. ## Fall back safely when the capture is stale Precompilation is an optimization, not a rendering dependency. A missing, partial, incompatible, or stale capture falls back to normal live building. The visitor may spend the original setup time, but the scene still renders. After a shader-relevant edit, run capture again. During development, the overlay reports **Shader capture required** until the new result is ready and **Shaders precompiled** after the runtime reconnects it successfully. Use the GPU-less strict check when a release must stop instead of shipping a stale optimization: ```sh npx three-blocks shaders test --skip-browser --mode strict ```
How reconnection works Capture stores generated WebGPU Shading Language (WGSL) or OpenGL Shading Language (GLSL), the finished builder state, and a uniform journal for each registered shader key. The journal records binding addresses rather than freezing values. At runtime, hydration replays those addresses against the current nodes, verifies the layout, and returns the captured builder state. Valid keys skip `nodeBuilder.build()` while their uniforms continue to change. Three Blocks writes `meta.json` last, so an interrupted capture never looks complete. The installed Three.js version, Three Blocks version, shader runtime closure, semantic inputs, and capture schemas must agree before hydration can use the result. The receipt also records the capture browser user agent, selected backend, adapter, and granted features as provenance; strict release checks remain the authority for whether the committed artifact can ship. If one key cannot reconnect, that key logs one error and builds live. Other valid keys can remain precompiled. WebGL precompilation covers render shaders only. Compute, storage-buffer writes, subgroups, PBO-backed storage reads, and unavailable required GLSL extensions stay on the live path with one warning. The separate legacy `WebGLRenderer` is not supported.
## Check before you ship Check freshness during ordinary development without a browser or graphics processor: ```sh npx three-blocks shaders ``` Use the strict release gate when stale artifacts must stop the build: ```sh npx three-blocks shaders test --skip-browser --mode strict ``` Use the [Devtools guide](/docs/tools/devtools) to add optional semantic shader keys, review bundler wiring, capture every production route, and add the strict release gate. ### SDF versus BVH constraints Canonical: https://threejs-blocks.com/docs/concepts/sdf-versus-bvh SDF and BVH queries trade sampled memory and update cost against direct geometric precision. ## Choose sampled or geometric queries Choose from update frequency, sign and precision needs, query count, and target memory. ## Fix SDF and BVH constraint mismatches Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### PBF versus SPH versus MPM Canonical: https://threejs-blocks.com/docs/concepts/simulation-choice Solvers that look similar in a still expose different stability, material, grid, and tuning costs. ## Choose a solver from the material behavior Prototype the same interaction and scale in plausible solvers before locking authoring work. ## Diagnose solver instability Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Splats versus live mesh versus render-baked presentation Canonical: https://threejs-blocks.com/docs/concepts/splats-versus-live-mesh-versus-baked The same product can trade runtime control, captured detail, and approved pixels differently. ## Choose which controls must stay live Rank required camera, light, material, geometry, and object freedoms before delivery cost. ## Check presentation tradeoffs Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Streaming versus preloading Canonical: https://threejs-blocks.com/docs/concepts/streaming-versus-preloading Startup, memory, seek behavior, and mid-playback risk move between preload and streaming. Decide from the bytes and resources that must be resident for one useful frame, not from the package's file extension. ## Choose when bytes enter memory Choose from asset size, first-use timing, seek pattern, memory ceiling, and fallback. Keep a useful host-owned result visible while either path acquires its resources. ## Preload small assets for deterministic access Preloading trades startup time and a known memory peak for deterministic local access after readiness. It fits small clips whose complete decoded texture array stays below the target device's layer and byte budgets. Do not extrapolate that choice to a 2D Baked Motion grid: hundreds of color and depth frames at 2K can require gigabytes of decoded texture memory even when the encoded package looks modest. Use an explicit preload strategy only after calculating every resident color, alpha, and depth layer. A resource-budget rejection should preserve the poster; it is not a reason to increase a global GPU limit blindly. ## Decode whole-file media with a bounded working set Whole-file media keeps a bounded decoded working set without paying a network round trip for every frame or GOP. Version 2 Baked Motion fetches each selected `.af` resource once, verifies its full hash, then asks WebCodecs only for the frames needed by the current timeline, rotation, or tilt sample. Budget the encoded body separately from decoded slots. `maxFullFileBytes` limits each downloaded resource, while `decodedCacheBudget` and strategy limits govern GPU residency. See [Baked Motion](/docs/blocks/baked-motion) for the deployment contract. ## Suspend media to reclaim decoder resources Visibility is an admission decision. Suspend media-backed experiences when the document is hidden or the experience is offscreen so decoder sessions can be reclaimed; retain the last valid texture to avoid a blank return. Resume only the active experience and restore its latest requested sample. Dispose on unmount to release requests, encoded cache ownership, frames, textures, and listeners. Reduced-motion policy comes before either strategy. If the product selects the poster, skip manifest fetch and decoder admission rather than preloading an animation that will not be shown. ## Recover from streaming and preload failures Trace the owner, first-use request, network bytes, verified cache bytes, decoder group, decoded residency, consumer, fallback, suspension, and disposal path in that order. A blank result means the fallback was released too early. A one-frame lag usually means the application sampled after rendering or failed to await the current `frameReady` generation. ### TSL composition Canonical: https://threejs-blocks.com/docs/concepts/tsl-composition Node effects become brittle when input space, output type, or render stage is implicit. ## Keep TSL inputs explicit State those contracts first and animate uniforms instead of rebuilding graphs. ## Fix mismatched TSL spaces and stages Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### WebGPU renderer initialization Canonical: https://threejs-blocks.com/docs/concepts/webgpu-initialization GPU-backed blocks cannot allocate safely until the renderer has selected and initialized its device. ## Initialize WebGPU before allocating resources Create the renderer, await init, then construct GPU resources and enter the frame loop. ## Fix WebGPU initialization order Trace the owner, input, GPU work, consumer, fallback, and disposal path in that order. A blank result or one-frame lag usually reveals the first missing boundary. ### Worker-owned rendering Canonical: https://threejs-blocks.com/docs/concepts/worker-owned-rendering Worker-owned rendering keeps the document and interaction lifecycle on the page while an `OffscreenCanvas`, the Three.js renderer, scene resources, and frame loop live in a module worker. Three Blocks provides two layers for that boundary: `three-blocks/app` is the assembled application shell, and `three-blocks/worker` is the renderer-agnostic typed transport underneath it. Use the application shell when a Three.js worker should participate in the starter lifecycle, hot replacement, text synchronization, performance panels, and development evidence. Drop to the transport when the protocol or worker has a different job. ## Keep page and worker responsibilities separate The page remains responsible for browser-owned state: - the canvas element and its replacement during a restart - viewport, pointer, scroll, and document-visibility input - DOM text observation and page-side performance panels - worker creation, disposal, and hot-module-replacement events The worker owns GPU state: - `WebGPURenderer` initialization and the animation loop - scenes, cameras, assets, shader registrations, and text meshes - compile-before-commit scene replacement - worker-side CPU, GPU, and texture-panel measurements That division keeps DOM access out of the worker and keeps GPU resources off the page. It also makes the boundary inspectable: state crosses named protocol lanes instead of hiding in ad hoc `postMessage` calls. ## Let WorkerHost own restart choreography `WorkerHost` from `three-blocks/app` creates the worker, transfers the canvas, opens the page and worker protocol endpoints, and publishes the initial boot state. It remembers the latest viewport, scroll, and visibility values so a replacement worker starts from the current page state rather than the values from the first load. An `OffscreenCanvas` cannot simply be transferred to a second worker. On restart, the host terminates the old worker, replaces the DOM canvas, transfers the replacement, reconnects both endpoints, and replays the tracked state. Supported Vite hot updates enter that same serialized restart path, so two restarts cannot race each other. Install the smoke bridge beside the host: ```ts file=src/main.ts import { createInputForwarder, installSmokeBridge, WorkerHost, } from "three-blocks/app"; const host = new WorkerHost({ canvas: "#scene", create: () => new Worker(new URL("./render.worker.ts", import.meta.url), { type: "module", }), hot: import.meta.hot, }); const input = createInputForwarder(host.link); const removeSmokeBridge = installSmokeBridge(host); ``` `createInputForwarder` publishes page input through the governed worker-state lanes and suppresses unchanged scroll frames. `installSmokeBridge` exposes the host's readiness and evidence ledger to the development overlay and browser smoke checks; call its returned cleanup function when the page module is disposed. ## Assemble worker services once After the worker initializes `WebGPURenderer`, `createWorkerRuntime` assembles the shared worker-side services: - a scoped asset manager with the standard Three.js adapters and Vite-managed codecs - the scene shader cache, compatibility check, and precompiled-manifest installation - CPU, GPU, and texture-panel stats published back to the page - optional worker text rendering driven by page-side text deliveries - scene contexts that lease assets and register shader-producing objects together Create one runtime for the renderer, ask it for a scene context when constructing a scene, and dispose it with the renderer. The runtime owns the registrations and adapter resources it creates. [Precompiled shaders](/docs/concepts/precompiled-shaders) explains the cache and fallback rules that runtime installation applies. The [Framework setup](/docs/start/frameworks) worker recipe shows the lower-level pieces individually. The generated [starter](/docs/start/starter) composes the complete runtime, frame dispatcher, and scene hot reloader. ## Keep the protocol seam visible Starter projects keep a local `src/protocol.ts` that re-exports `AppProtocol` and the shared scene/input types from `three-blocks/app`. Page and worker files import those types through the local module. That small seam gives the application one obvious place to replace or extend its message contract without scattering package imports across both sides. The standard app protocol has separate state, event, and request lanes in each direction. Boot transfer, input, lifecycle, diagnostics, stats, text replay, and errors use those typed lanes. Development builds can enable structured-clone validation so an invalid payload fails where it crosses the boundary. Use `three-blocks/worker` directly when: - the page and worker need application-specific state, events, or RPC requests - the worker does not own a Three.js renderer - worker replacement must follow a lifecycle other than `WorkerHost` - an existing protocol already defines ownership and error handling The transport exports typed clients and servers, endpoint replacement, transfer helpers, structured-clone types, and serialized worker errors. It deliberately knows nothing about Three.js. Using it directly also means the application owns canvas replacement, state replay, readiness, and devtools evidence that `three-blocks/app` normally supplies. ## Carry development evidence across the boundary The overlay runs on the page, but the evidence originates on both sides. The worker publishes lifecycle stages, shader mode and build counters, profiler snapshots, and optional texture frames. `WorkerHost` folds them into the protocol-versioned smoke state, tracks worker generation and restart replay, and exposes panel controls to the overlay. This is why a worker-owned renderer should not call the page-owned `registerDevtools({ renderer })` recipe. Use `WorkerHost` and the smoke bridge so evidence crosses the same typed boundary as the application state. The [Devtools guide](/docs/tools/devtools) explains how the overlay reads that evidence and how shader capture, text generation, and strict release checks fit around it. ### Interactive experiences Canonical: https://threejs-blocks.com/docs/create/interactive-experiences Make one interaction owner responsible for pointer, scroll, camera, layout, pause, resize, HMR, and disposal. ## Choose from the outcome Start with the information or action that must survive reduced motion and missing WebGPU, then choose text, interaction, sampling, culling, and batching blocks. ## Production handoff Record the representation, quality tier, fallback, asset revision, frame order, and owner before the visual moves from prototype to a shipping page. ### Product visualization Canonical: https://threejs-blocks.com/docs/create/product-visualization Present an object with convincing material, motion, and interaction while keeping the browser payload and runtime predictable. ## Choose what the browser should own The best representation depends on what must remain live after the page loads. Do not choose a pipeline only because its demo looks closest to the final shot. | If you need | Start with | Trade-off | |---|---|---| | Live lighting and arbitrary camera movement | A mesh with [Transmission](/docs/blocks/transmission) or another node material | The browser pays geometry, shading, and scene-management costs every frame. | | A controlled camera response around a finished render | [Baked Motion](/docs/blocks/baked-motion) | The authored image stays intact, but viewpoints and lighting are limited to captured dimensions. | | Deforming geometry with a live material | [Vertex Animation Video](/docs/blocks/vertex-animation-video) | Geometry can stream efficiently, but quantization, interpolation, topology, and bounded residency become production constraints. | | Many independently addressable rigid parts | [Object Animation Video](/docs/blocks/object-animation-video) | Authored transforms stay compact while geometry and materials remain live, but names, hierarchy, binding, and numerical-package compatibility become contracts. | | A captured object or space with view-dependent detail | [Gaussian Splats](/docs/blocks/gaussian-splats) | Capture can preserve appearance that is expensive to rebuild, while sort, memory, and mobile fallback costs need explicit budgets. | At Utsubo, the useful question is usually “what still needs to react?” If only the camera relationship changes, a render-baked presentation can preserve more art direction with less runtime work. If lighting, material parameters, or geometry must react independently, keep those parts live and budget them as a real-time scene. ### Visual effects Canonical: https://threejs-blocks.com/docs/create/visual-effects Add atmosphere or physical behavior with an explicit render order and quality ladder instead of a demo-only effect. ## Choose from the outcome Decide whether the effect needs real volume or only image treatment, then budget simulation, reconstruction, compositing, DPR, and fallback together. ## Production handoff Record the representation, quality tier, fallback, asset revision, frame order, and owner before the visual moves from prototype to a shipping page. ### Render your first Three Blocks scene Canonical: https://threejs-blocks.com/docs/start/first-scene Build one visible result: a rotating refractive object that proves Three.js, WebGPU, and Three Blocks are working together. Add the code below to `src/main.ts`, run `bun run dev`, and open `http://localhost:5173` unless Vite reports another port. ## Install and run In a Vite TypeScript project, install the renderer and the block: ```sh bun add three three-blocks bun run dev ``` Keep the development server open. Replace `src/main.ts` with the scene below, then check the browser for a pale glass object rotating over a dark background. ## Build the refractive scene ```ts file=src/main.ts import * as THREE from "three/webgpu"; import { MeshTransmissionNodeMaterial } from "three-blocks/transmission"; const renderer = new THREE.WebGPURenderer({ antialias: true }); renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2)); renderer.setSize(window.innerWidth, window.innerHeight); document.body.append(renderer.domElement); await renderer.init(); const scene = new THREE.Scene(); scene.background = new THREE.Color(0x111318); const camera = new THREE.PerspectiveCamera( 45, window.innerWidth / window.innerHeight, 0.1, 100, ); camera.position.set(0, 0, 4); const geometry = new THREE.IcosahedronGeometry(1, 5); const material = new MeshTransmissionNodeMaterial({ color: 0xcde3ff, roughness: 0.12, thickness: 0.65, transmission: 1, }); const object = new THREE.Mesh(geometry, material); scene.add(object); const light = new THREE.DirectionalLight(0xffffff, 3); light.position.set(2, 3, 4); scene.add(light); function resize() { camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } function frame(time: number) { object.rotation.y = time * 0.00025; object.rotation.x = time * 0.0001; renderer.render(scene, camera); } function dispose() { renderer.setAnimationLoop(null); window.removeEventListener("resize", resize); geometry.dispose(); material.dispose(); renderer.dispose(); } window.addEventListener("resize", resize); window.addEventListener("pagehide", dispose, { once: true }); renderer.setAnimationLoop(frame); ``` `await renderer.init()` is the boundary to remember. Create GPU-backed block resources after it, run compute or simulation updates before `render`, and stop the loop before disposing resources. Three Blocks does not replace Three.js. Three.js still owns the scene, camera, renderer, geometry, and render loop. A Three Blocks capability joins that scene and states when it needs initialization, per-frame work, resize handling, or disposal. ## Add development tooling This scene stops at the renderer lifecycle. Continue with [Devtools](/docs/tools/devtools) for the canonical Vite and runtime recipes, overlay, shader precompilation, text preparation, environment bake, and release gates. Open the [Transmission example](/examples/webgpu_material_transmission) to see the same material in a complete lit scene. Then choose the path that matches the experience you want to make: [Product visualization](/docs/create/product-visualization), [Interactive experiences](/docs/create/interactive-experiences), or [Visual effects](/docs/create/visual-effects). ### Framework setup Canonical: https://threejs-blocks.com/docs/start/frameworks Add Three Blocks development status and TSL build timing to an existing framework scene without giving up the framework's render loop. Make the first edit in the file that creates your `WebGPURenderer`, run the project's development command, and open its local URL: | Framework | First edit | Command | Default local URL | | --- | --- | --- | --- | | React Three Fiber with Vite | `src/App.tsx` | `bun run dev` | `http://localhost:5173` | | Next.js | `app/scene.tsx` | `bun run dev` | `http://localhost:3000` | | Vue with TresJS | `src/App.vue` | `bun run dev` | `http://localhost:5173` | | Plain webpack | `src/main.ts` | Your existing start script | The URL printed by webpack | Every framework uses the same devtools registration line. Place `registerDevtools({ renderer })` in the callback or client lifecycle that receives the initialized `WebGPURenderer`; the framework keeps control of rendering, reactivity, and cleanup. That line also discovers committed shader manifests and keeps hydration active in production while the overlay and panels erase. Run `npx three-blocks shaders capture` after registration. The first run creates the default `/` capture route. Vite projects add `threeBlocks()` beside their existing plugins. For Next.js, webpack, Rollup, and esbuild, the command detects the bundler, previews the exact adapter diff, and asks before changing the configuration. It then starts Next.js or builds and serves the static output itself. Use `--yes` only after reviewing the diff in a noninteractive workflow. ## Let capture wire the bundler The normal path is one command: ```sh npx three-blocks shaders capture ``` The previewed patch uses `withThreeBlocksNext()` or `withThreeBlocksWebpack()` for webpack-family configurations and the matching plugin for Rollup or esbuild. The wrappers compose existing callbacks and preserve normal application ownership. The provider hook remains in production; capture instrumentation is included only in the tool-managed build. Pass `--url ` to attach to a server you started, or `--driver static --serve ` for a nonstandard output directory. Those explicit modes do not offer configuration edits. The Next.js and Plain webpack sections below contain the manual adapter forms. ## React Three Fiber React Three Fiber (R3F) accepts an asynchronous `gl` factory for `WebGPURenderer`. Register the concrete renderer after initialization, before returning it to the canvas: ```tsx file=src/App.tsx import { Canvas } from "@react-three/fiber"; import * as THREE from "three/webgpu"; import { registerDevtools } from "three-blocks/devtools"; export function App() { return ( { const renderer = new THREE.WebGPURenderer( props as THREE.WebGPURendererParameters, ); await renderer.init(); registerDevtools({ renderer }); return renderer; }} > {/* your scene */} ); } ``` R3F owns the frame loop. The registration observes the renderer without changing that ownership. ## Next.js Create the renderer in a Client Component. Registration happens after `renderer.init()` resolves, never during server rendering: ```tsx file=app/scene.tsx "use client"; import { useEffect, useRef } from "react"; import * as THREE from "three/webgpu"; import { registerDevtools } from "three-blocks/devtools"; export function Scene() { const canvas = useRef(null); useEffect(() => { let active = true; let initialized = false; let registration: ReturnType | undefined; const renderer = new THREE.WebGPURenderer({ canvas: canvas.current! }); void renderer.init().then(() => { initialized = true; if (!active) return renderer.dispose(); registration = registerDevtools({ renderer }); }); return () => { active = false; registration?.dispose(); if (initialized) renderer.dispose(); }; }, []); return ; } ``` Running `npx three-blocks shaders capture` previews this wrapper when it is missing: ```ts file=next.config.ts import type { NextConfig } from "next"; import { withThreeBlocksNext } from "@three-blocks/devtools/transform"; const nextConfig: NextConfig = { // Your existing webpack callback is composed, not replaced. }; export default withThreeBlocksNext(nextConfig); ``` After consent, capture starts the project-local Next.js development server in webpack mode, captures the route, and shuts the server down: ```sh npx three-blocks shaders capture ``` Production-aware Next builds select the hydration-only condition. Overlay and stats implementation stay out of client chunks; the small shader hydrator remains. ## Vue with TresJS TresJS accepts a custom `WebGPURenderer` factory and emits `ready` after initialization. Register the raw renderer from that event: ```vue file=src/App.vue ``` TresJS owns initialization and the frame loop. Registration starts only after its `ready` event exposes the initialized renderer. ## Plain webpack Register immediately after the renderer initializes: ```ts file=src/main.ts import * as THREE from "three/webgpu"; import { registerDevtools } from "three-blocks/devtools"; const renderer = new THREE.WebGPURenderer({ antialias: true }); await renderer.init(); registerDevtools({ renderer }); ``` Running capture previews `withThreeBlocksWebpack()` around the existing configuration. After consent, it runs the project's build script with capture instrumentation and serves a single-page app from `dist/`, `build/`, or `out/` automatically: ```sh npx three-blocks shaders capture ``` For a manual configuration, import `withThreeBlocksWebpack` from `@three-blocks/devtools/transform` and wrap the exported webpack configuration. Alternatively start the development server with `THREE_BLOCKS_SHADER_TOOL=1` and pass its URL with `--url`. ## Ship it Commit `.three-blocks/shaders/` and `public/three-blocks/shaders/`, then add: ```sh npx three-blocks shaders test --skip-browser --mode strict ``` This CI check needs no browser or GPU. Use `--reporter json` for annotations, and add the full `shaders test` only on a WebGPU runner. ## Worker-owned renderers Do not call the page-owned registration when your renderer lives in a worker. Use the governed `three-blocks/app` host and protocol instead. [Worker-owned rendering](/docs/concepts/worker-owned-rendering) explains the page/worker split, restart choreography, runtime assembly, and when to use the lower-level transport directly. ### Mount the worker host The page host transfers the canvas and publishes the bridge that the development overlay consumes. Put `` in your page, then create the host: ```ts file=src/worker-host.ts /// import { createInputForwarder, installSmokeBridge, WorkerHost, } from "three-blocks/app"; const host = new WorkerHost({ canvas: "#scene", create: () => new Worker(new URL("./render.worker.ts", import.meta.url), { type: "module", }), hot: import.meta.hot, }); const input = createInputForwarder(host.link); const removeSmokeBridge = installSmokeBridge(host); const lifecycle = new AbortController(); const viewport = () => ({ width: window.innerWidth, height: window.innerHeight, dpr: Math.min(window.devicePixelRatio, 2), }); input.viewport(viewport()); input.scroll({ progress: 0, position: 0, velocity: 0, direction: 0 }); input.visibility({ visible: document.visibilityState === "visible" }); window.addEventListener("resize", () => input.viewport(viewport()), { signal: lifecycle.signal, }); document.addEventListener( "visibilitychange", () => input.visibility({ visible: document.visibilityState === "visible" }), { signal: lifecycle.signal }, ); const dispose = () => { lifecycle.abort(); removeSmokeBridge(); host.dispose(); }; window.addEventListener("pagehide", dispose, { once: true }); import.meta.hot?.dispose(dispose); ``` ### Create the worker renderer `WorkerHost` transfers the canvas, restarts the worker after supported hot updates, and owns the page-side smoke and stats state. The worker publishes typed lifecycle and profiler messages through the app protocol. Start `src/render.worker.ts` with the shared state and reporting helpers: ```ts file=src/render.worker.ts /// /// import * as THREE from "three/webgpu"; import { AppStatsWorkerController, errorMessage, type AppPageEvents, type AppPageRequests, type AppPageState, type AppWorkerEvents, type AppWorkerRequests, type AppWorkerState, type PageLink, type RuntimeStatus, type ScrollState, } from "three-blocks/app"; import { createWorkerClient, createWorkerServer, serializeWorkerError, } from "three-blocks/worker"; let page: PageLink | undefined; let renderer: THREE.WebGPURenderer | undefined; let camera: THREE.PerspectiveCamera | undefined; let stats: AppStatsWorkerController | undefined; let viewport = { width: 1, height: 1, dpr: 1 }; let scroll: ScrollState = { progress: 0, position: 0, velocity: 0, direction: 0, }; let visible = true; let firstFrameComplete = false; const workerId = crypto.randomUUID(); ``` Add the reporting and resize helpers to the same worker file: ```ts file=src/render.worker.ts function setStatus(value: RuntimeStatus): void { page?.state.set("lifecycle", value); } function resize(): void { if (renderer === undefined || camera === undefined) return; renderer.setPixelRatio(viewport.dpr); renderer.setSize(viewport.width, viewport.height, false); camera.aspect = viewport.width / Math.max(viewport.height, 1); camera.updateProjectionMatrix(); } function publishDiagnostics(): void { if (!firstFrameComplete) return; page?.state.set("diagnostics", { workerId, viewport, scroll, visible, shaderMode: "live", }); } function reportError(error: unknown): void { setStatus({ stage: "error", detail: errorMessage(error) }); page?.events.emit( "error", serializeWorkerError(error, { source: "render.worker", lifecyclePhase: "transport", }), ); } ``` Finish the worker with renderer initialization, frame profiling, and protocol handlers: ```ts file=src/render.worker.ts async function initialize(boot: AppWorkerState["boot"]): Promise { const activePage = createWorkerClient< AppPageState, AppPageEvents, AppPageRequests >(); await activePage.replaceEndpoint(boot.page); page = activePage; setStatus({ stage: "worker ready" }); const scene = new THREE.Scene(); const activeCamera = new THREE.PerspectiveCamera(45, 1, 0.1, 100); activeCamera.position.z = 3; scene.add( new THREE.Mesh( new THREE.BoxGeometry(), new THREE.MeshBasicMaterial({ color: 0x6f89ff }), ), ); const activeRenderer = new THREE.WebGPURenderer({ antialias: true, canvas: boot.canvas, }); camera = activeCamera; renderer = activeRenderer; await activeRenderer.init(); resize(); const activeStats = new AppStatsWorkerController({ renderer: activeRenderer, publish: (snapshot) => activePage.state.set("stats", snapshot), }); stats = activeStats; void activeStats .applyControl({ active: true, visible: false, mode: "compact" }) .catch((error: unknown) => console.warn("[stats]", error)); setStatus({ stage: "assets ready" }); await activeRenderer.compileAsync(scene, activeCamera); setStatus({ stage: "compiled" }); activeRenderer.setAnimationLoop(() => { if (!visible) return; activeStats.beginFrame(); activeRenderer.render(scene, activeCamera); activeStats.endFrame(); if (firstFrameComplete) return; firstFrameComplete = true; setStatus({ stage: "first frame" }); publishDiagnostics(); }); } createWorkerServer(self, { state: { boot: (value) => void initialize(value).catch(reportError), viewport: (value) => { viewport = value; resize(); publishDiagnostics(); }, scroll: (value) => { scroll = value; publishDiagnostics(); }, visibility: (value) => { visible = value.visible; publishDiagnostics(); }, }, }); import.meta.hot?.dispose(() => { renderer?.setAnimationLoop(null); stats?.dispose(); page?.dispose(); }); ``` This recipe keeps the renderer and profiler in the worker while `WorkerHost` exposes the same readiness and stats contract to the development overlay. It reports live shader mode because it does not install a precompiled shader cache. For precompiled shaders, assets, synchronized text, and scene hot replacement, start from the generated [Three Blocks starter](/docs/start/starter), which composes those systems through `createWorkerRuntime`. Use the [worker-owned rendering concept](/docs/concepts/worker-owned-rendering) as the architectural reference when adapting that shell. ### Start with the starter Canonical: https://threejs-blocks.com/docs/start/starter Start with a generated project that already shows a pointer-reactive scene. Run one command, open `http://localhost:4000` unless Vite prints another port, and make your first visual edit in `src/scene.ts`. ## Scaffold and run ```sh npx three-blocks starter ``` Choose **Minimal** for one pointer-reactive scene or **Website** for selectable DOM copy mirrored as MSDF text. The completion panel prints the exact directory and package-manager commands. Run them, then open `http://localhost:4000` unless Vite reports another port. The starter reports four visible states: 1. **Starting** while the scene and its assets load 2. **Ready** after the first frame appears 3. **Precompiled** while the committed WebGPU/WebGL capture matches the scene 4. **Live** after a shader-relevant edit needs ordinary live building The starter's built-in readiness check confirms the same states before you ship. ## Make the first edit Open `src/scene.ts`. The exported `Experience` group owns the objects, materials, animation, and scene-local assets that you are expected to change. Replace a color, move one of the three brand shapes, or change its pointer or scroll response. Vite swaps the scene transactionally while the worker and declared `hot` state stay alive. Do not move renderer code into `src/main.ts`. That file owns DOM input and the worker host; `src/render.worker.ts` owns the renderer and frame loop. ## Read development status The starter reports `shaders precompiled` while its committed capture matches the scene and `shaders live` after a shader-relevant edit. Read [Precompiled shaders](/docs/concepts/precompiled-shaders) for the safety model and [Devtools](/docs/tools/devtools) for the overlay, preparation commands, and release gates. ## License boundary Personal and noncommercial projects are free. Pro grants each Project started during an active period a lifetime commercial license for versions released during that period. After cancellation, you may maintain, update, and distribute the Project with those covered versions and keep using Pro Tool versions obtained while active for that Project locally and offline. Starting a new commercial Project, adopting a later version, or downloading or updating a Pro Tool requires an active seat. Covered versions have no runtime gate. The generated project includes a `NOTICE` with the controlling terms links. Already own a renderer lifecycle? Continue with [Render your first Three Blocks scene](/docs/start/first-scene). Integrating a framework? Use [Framework setup](/docs/start/frameworks). ### Baked Motion Video Canonical: https://threejs-blocks.com/docs/tools/baked-motion-video Author a timeline, rotation, or tilt camera array in Blender, then encode synchronized color, embedded alpha, and optional depth into a verified Baked Motion package. ## Headless Blender bake Pass a `.blend` directly to render the camera array, create its semantic manifest, and encode the package without the add-on UI: ```sh three-blocks tools utsbv ~/Desktop/chip.blend \ --object YourChipObject --mode tilt --tilt-range 20 --tilt-count 19 \ --projection ortho --depth --resolution 2048 --format 2 \ --out /tmp/chip-v2.utsbv ``` Run `three-blocks tools utsbv scene.blend` to review every bake setting in one editable list before starting. The command uses the same camera planner, renderer, manifest writer, export resolver, and gated encoder as the add-on. Blender's engine, device, samples, and denoising remain those saved in the scene unless `--samples` is passed. The lower-level frames-folder form still accepts an existing `manifest-params.json` with `--manifest`. ## Artifact boundary Treat the complete `.utsbv` directory as one immutable artifact. Its semantic manifest, referenced resources, hashes, and `build-report.json` must come from the same encoder transaction. Never replace one track or manifest in place. Version 2 packages use rational frame rate metadata and duplicate the runtime frame/GOP index into `manifest.json`. The runtime fetches each `.af` resource once, verifies its full byte length and SHA-256, and forwards its encoded frames to WebCodecs. Version 1 remains an intentional rollback format. Version 3 keeps that contract and adds a paged atlas: neighbouring views share one coded frame, and every stream is indexed into hashed byte-range segments so the runtime admits only the pages around the current view instead of whole tracks. It covers tilt and rotation grids; timeline packages stay on version 2, which is also the default for a new encode. ## Renditions Encode all renditions from the same post-dilation source. Independent dilation or preprocessing passes can shift silhouettes and depth edges between quality levels, making a decoder fallback visibly jump. Official packages authored above 1024 pixels need at least the authored width and one half-width verified rendition, with a 512-pixel floor. A 2048-pixel source therefore ships 2048 and 1024; smaller assets may remain single rendition. Extra widths are an authoring decision, not a runtime resize. The runtime's automatic policy can select only renditions present in this verified ladder. An explicit runtime rendition ID must match a manifest ID and never silently downgrades. ## Smooth proxy and per-view depth New format 2 encodes include a 128-pixel, all-intra proxy by default. The proxy is package-wide (`resources.proxy`), not another selectable full-resolution rendition. It gives the runtime a complete resident view grid while authored renditions finish admission. Use `--proxy-size EVEN_PIXELS` to change its width or `--no-proxy` for a compatibility draft. Proxy quality inherits the primary settings unless you override it. Format 2 accepts `--proxy-crf` for color, `--proxy-alpha-crf` for alpha, and either `--proxy-depth-qp` or `--proxy-depth-crf` for depth. The two proxy depth modes are mutually exclusive. Use these controls to make the resident continuity floor sharper without needlessly increasing the full-resolution tracks, then let the selected quality profile accept or reject the emitted proxy from its decode-back metrics. The exact codec arguments remain recorded in `build-report.json`. When depth is present, format 2 also normalizes every view over its occupied camera-space range and records the true `[minimum, maximum]` pairs in `tracks.depth.frameRanges`. Code 255 remains the empty sentinel. Disable this only when testing legacy package-wide normalization with `--no-depth-range-compaction`. Upgrade an existing package from its own encoded tracks without Blender or a new render: ```sh three-blocks tools utsbv refresh clip.utsbv ``` The refresh is an atomic transcode. It preserves the original render semantics, adds the proxy and depth range table, and emits the same manifest, index, and build-report evidence as a new format 2 encode. Pass `--to` to choose the refresh target: 2 by default, or 3 to repack a tilt or rotation package as a paged atlas. ## Enforce `build-report.json` The production encoder path performs decode-back verification before atomic publication. The command-line verification opt-out is for local drafts only: it must write `verification.status: "skipped"`, and a skipped report is not publishable. A release or asset-publishing job must validate the report against the shipped build-report schema and then enforce all of these conditions: - `reportVersion` is supported by the publishing job; - `verification.requested` is `true` and `verification.status` is `passed`; - `verification.profile.status` is `calibrated`, with the exact frozen metrics and thresholds required by that profile; - every expected rendition and stream appears with dimensions, frame count, codec envelope, byte length, whole-resource hash, and index hash; - source, encoded, and verified frame census values agree with the manifest; - `atomicOutput.status` is `committed` and `atomicOutput.temporaryOutput` is `published`; - any project policy for warnings is applied explicitly. Do not gate on the existence of `build-report.json` alone, and do not rewrite a failed or skipped status in downstream automation. A quality profile marked `uncalibrated` cannot produce a production pass. Preserve the report beside the package so a deployed artifact can be traced to its source hashes, generator, FFmpeg fingerprint, codec arguments, verification samples, and thresholds. The report is designed to be durable and privacy-safe: absolute user paths, credentials, hostnames, IP addresses, and environment secrets are forbidden. Treat a report rejected by this sanitization as an encoder failure, not as a file to clean up after publication. ## What verification proves Verification decodes emitted streams back to pixels and compares them with the post-dilation source. It checks RGB, alpha, and depth metrics; frame counts, dimensions, descriptions, GOPs, and timestamps; wrapping seams and duplicated loop endpoints; segment and whole-file hashes; hardware envelopes; and the worker/chunk census. Thresholds are versioned quality-profile data. Changing a threshold is a tooling decision that needs a profile version and before/after evidence. Encoding, indexing, verification, manifest/report writing, and cross-checking occur in a temporary package directory. Only a complete passing package may be swapped into the destination. A failed build must leave an existing published directory untouched. ## Before runtime integration Keep source, settings, tool version, quality profile, manifest, report, and generated media on one immutable revision. Exercise the exact deployed package in the browser matrix; an encoder hardware-envelope calculation is advisory and does not prove browser decoder admission. Use [Baked Motion](/docs/blocks/baked-motion) for poster ownership, typed runtime outcomes, rendition policy, visibility lifecycle, and the whole-file hosting contract. In particular, the CDN must preserve `.af` bytes and must not apply `Content-Encoding` transformations. ### Devtools Canonical: https://threejs-blocks.com/docs/tools/devtools Three Blocks devtools does two jobs. While you develop, it shows what your app is doing through an overlay chip, optional performance panels, terminal output, and a status bridge. Before you ship, it prepares shaders, text atlases, and environment lighting on your machine so the browser can load committed artifacts instead of repeating that work. Three Blocks devtools has one product surface. The runtime face is `three-blocks/devtools` plus the always-on `three-blocks/shaders` hydrator. The command face is `npx three-blocks`; it detects and offers the provider adapter required by Vite, webpack/Next, Rollup, or esbuild. ## Add devtools to your app Choose the recipe that matches where your app creates its renderer. ### Start from the Three Blocks starter The starter already wires the renderer, Vite plugin, overlay, shader capture, text preparation, and release gates: ```sh npx three-blocks starter ``` Continue with [Start with the starter](/docs/start/starter) after generation finishes. ### Add devtools to any Vite app Add `threeBlocks()` beside your existing framework plugins. The plugin infers page ownership in an existing app and reads `three-blocks.shaders.json` when you add shader precompilation: ```ts file=vite.config.ts import { defineConfig } from "vite"; import { threeBlocks } from "three-blocks/vite"; export default defineConfig(({ mode }) => ({ plugins: [threeBlocks({ shaders: { strict: mode === "strict" } })], })); ``` Register the renderer where your app creates it: ```ts file=src/main.ts import { registerDevtools } from "three-blocks/devtools"; registerDevtools({ renderer }); ``` That completes the runtime and shader integration. The plugin prints a preflight when the dev server starts, injects the overlay, keeps shader state current, and reloads the page when a fresh capture arrives. Production removes overlay and stats implementation while retaining the bounded shader hydrator. Pass a text configuration when you add the text preparation workflow below. ### Add devtools to any other stack Next.js, webpack, and other bundlers use the same `registerDevtools({ renderer })` line shown above. The registration mounts the overlay chip, performance panels, and built-in readiness check. It also fetches the convention manifest and installs hydration before the renderer's first build. Production-aware bundlers select the hydration-only condition, so overlay and stats implementation do not enter client chunks. Start the app in development, open the overlay, and click **Capture shaders** when its hero reports **Shader capture required**. Use the command-line capture for an isolated route batch or CI regeneration: ```sh npx three-blocks shaders capture ``` For Next.js, webpack, Rollup, and esbuild, that fallback command inspects the project and prints the exact missing adapter diff. It applies that diff only after a `y/N` confirmation. Use `--yes` after reviewing the diff in CI or another noninteractive shell. Capture then starts a project-local Next.js server or runs the project's build and serves `dist/`, `build/`, or `out/`. Use `--driver static --serve dist` for a nonstandard output directory, or `--url http://localhost:3000` to attach to a running framework server. Explicit driver and URL modes do not modify configuration. [Framework setup](/docs/start/frameworks) contains the manual adapter forms. The support boundary is explicit: | Capability | Vite with `threeBlocks()` | Adapter + static/attached driver | |---|---|---| | Overlay, performance panels, readiness states | Yes | Yes | | Terminal preflight and reload after capture | Yes | App-owned | | Render shader and WebGPU compute precompilation | Yes | Yes | | GPU-less strict CI gate | Yes | Yes | | Production payload | Hydration only | Hydration only | [Framework setup](/docs/start/frameworks) shows where to place the line in React Three Fiber, Next.js, TresJS, webpack, and worker-owned apps. `registerDevtools` observes a page-owned `WebGPURenderer`, including its WebGL fallback backend. It does not support the separate legacy `WebGLRenderer`. If your renderer runs in a worker, use `three-blocks/app` to publish the same status and performance evidence across the worker boundary. [Worker-owned rendering](/docs/concepts/worker-owned-rendering) explains that protocol and restart lifecycle. ## Use the Three.js r185 compatibility layer Shader precompilation currently supports Three.js `>=0.185.0 <0.186.0`. Every bundler adapter applies the same version-gated transform to `three/build/three.webgpu.js` in memory, and no adapter writes to `node_modules`. Exact source anchors stop the build when the installed Three.js source does not match the supported release. The r185 transform contains four changes: - [Three.js #34068](https://github.com/mrdoob/three.js/pull/34068) exposes the node-builder callback used to capture render and compute shaders. - [Three.js #34069](https://github.com/mrdoob/three.js/pull/34069), plus its local GLSL backport, gives named node buffers deterministic labels. - [Three.js #34070](https://github.com/mrdoob/three.js/pull/34070) exposes the provider used to hydrate captured builder state before a live build. - The local `compileAsync()` patch collects pipeline promises across one compile pass, yields after 8 ms work slices, and awaits the pipelines together while keeping WebGPU error scopes balanced. Run `npx three-blocks shaders` to see the manifest and receipt versions the installed release requires. After upgrading from an older artifact, run `npx three-blocks shaders capture`; do not edit generated manifests. Development falls back to live builds when an artifact is stale, while the strict release check rejects it. ## Read the development overlay The corner chip summarizes the app state. Open it for a hero summary, an optional **Profiler** dock, and a **Details** disclosure: - The hero states the shader mode and build count, such as **Shaders precompiled** with `N → 0` **TSL builds at startup**, plus `≈X ms` **NodeBuilder time saved** when the current capture includes timing - **Runtime**: a `renderer` ownership row, a `startup` boot-stage row, a `receipt` row with the shader state and captured pipeline count, a `text` atlas row, and a `performance` row - **Metrics**: application metrics registered through `setMetric`, when any exist - **HMR**: recent hot module replacement events, in development only - **Profiler**: on-demand `stats-gl` panels for frames per second (FPS), central processing unit (CPU), graphics processing unit (GPU), and compute timing The overlay follows a truth ladder. A live first load reports the session build count and cumulative TSL time. A precompiled load reports skipped builds only after hydration succeeds. Timing belongs to the current capture, so a shader-relevant edit changes the timing state to **Capture estimate unavailable** until you capture again. The profiler stays off until you open it. Add its optional dependency once with `bun add -d stats-gl`; the `performance` row reads `unavailable` and the button becomes **Retry performance** if you open the profiler without it. Use `?tbOverlay=0` to hide the overlay for the current session. Use `?tbStats=1` or `?tbStats=0` to override the stored profiler preference. ### Capture stale shaders from the overlay When a shader input changes, the `receipt` row switches to `stale` and the hero offers **Capture shaders**. Click it to capture the configured scene for the current route. The page reloads once, runs its real render and compute builds, and reports **Starting…**, **Building N/N**, **Settling…**, then **Writing…**. Keep the tab visible during capture. A hidden or occluded tab cannot advance animation frames, so the countdown pauses and the overlay says **Keep this tab visible**. Use **Cancel** to stop and return to normal development. Validation, collision, or input-drift failures appear in the panel with a **Copy** action. After the artifact is written, the existing dev-server watcher reloads the page. A **shaders captured** toast appears and the `receipt` row becomes `fresh` after the new manifest hydrates. The receipt records the browser user agent, selected backend, adapter, and granted features that produced it. An overlay capture covers one configured scene—the one open in this tab. The hero counts any other stale scenes; use `npx three-blocks shaders capture` for a route matrix, automated regeneration, or CI. If the optional command package is unavailable, the button becomes **Copy capture command** instead of pretending it can write artifacts. ## Prepare work ahead of time Every preparation workflow follows one shape: **capture once on your machine, commit the artifact, let the runtime hydrate it, and fall back to live work when it becomes stale.** Treat the generated files like a lockfile. An edited input, new Three.js version, missing entry, or invalid receipt never breaks the app. That unit performs the work live, and the overlay reports why. Run `vite build --mode strict` when a release must reject stale preparation artifacts. ### Precompile shaders to skip TSL builds Three.js `WebGPURenderer` turns every Three Shading Language (TSL) material into WebGPU Shading Language (WGSL) or OpenGL Shading Language (GLSL) on your visitor's machine. WebGPU compute nodes also use this path. This central processing unit work builds the graph and generates shader code before the first render. Browser pipeline caches cover the later native pipeline step, so they cannot remove the TSL build. Precompiled shaders hydrate the captured builder state so `nodeBuilder.build()` does not run. [How precompiled shaders work](/docs/concepts/precompiled-shaders) explains the capture journal, compatibility checks, fallback ladder, limits, and receipts. #### Read the TSL build time saved When the current capture includes timing, the overlay shows the TSL build time saved in milliseconds for this scene. Run `npx three-blocks shaders test` to record timing after shader inputs settle. Treat the result as feedback for this capture, not as a ranking of devices, implementations, or unrelated scenes. The command writes receipt-matched local timing to `.three-blocks/shaders/timing.local.json`. Pass `--commit-timing` when the project intentionally shares the same timing with its adapter and platform labels; that also writes `.three-blocks/shaders/timing.json`. A later shader edit makes either file unavailable until it matches a fresh capture. With no shader configuration, capture uses a `default` scene at `/`. Add `three-blocks.shaders.json` only when the app needs additional routes, a semantic scene name, or an explicit readiness signal: ```json file=three-blocks.shaders.json { "schemaVersion": 1, "backend": "both", "scenes": [{ "key": "main", "url": "/" }], "readiness": { "global": "__THREE_BLOCKS_READY__" } } ``` The default backend is `both`. Set `backend` to `webgpu` or `webgl` only for a single-lane release. In development, the overlay switches the active precompiled backend and shows the pooled WGSL/GLSL source size for each lane. The readiness global may be `true` or a promise. A `selector` is also supported. With no override, capture waits for the engine's settled-frame and first-frame contract; it does not inspect application-specific loading DOM. The one-line path automatically assigns deterministic, scene-scoped keys to otherwise unregistered render and compute builds. Explicit keys are still recommended when an app has conditional routes, needs semantic names in diagnostics, or wants a strictly declared capture matrix: ```ts file=src/scene.ts import { createShaderCache } from "three-blocks/shaders"; export const sceneKey = "main"; export const shaders = createShaderCache(sceneKey); shaders.material("main/hero", heroMaterial); shaders.compute("main/simulate", simulateCompute); shaders.pipeline("main/post", postProcessing); shaders.container("main/shared", sharedUniforms); ``` Keep explicit keys stable across runs and releases. Give important compute kernels semantic keys. Preserve the literal `.material(`, `.pipeline(`, `.compute(`, and `.container(` calls in shader-relevant source because the freshness scanner uses them as semantic roots. Explicit application keys take precedence over automatic keys, and Three Blocks blocks register their internal kernels. The normal installation is the same registration line used by the overlay. Capture emits `/three-blocks/shaders/..json` under `public/`. Registration fetches the active renderer backend's asset, validates its Three.js compatibility, and queues only the latest first render while it loads. An explicit `installShaderCache()` call still wins for apps that own custom manifest transport. ```ts file=src/shader-installation.ts import { createThreeWebGLShaderCompatibility, createThreeWebGPUShaderCompatibility, installShaderCache, } from "three-blocks/shaders"; const webgl = renderer.backend.isWebGLBackend === true; const installation = await installShaderCache({ renderer, scene: "main", state: threeBlocksShaders, loadManifest, compatibility: (webgl ? createThreeWebGLShaderCompatibility : createThreeWebGPUShaderCompatibility)({ threeVersion: threeBlocksConfig.threeVersion, }), cache: shaders, }); ``` After the overlay finishes, run the fast no-browser freshness check. Add the strict check and browser parity lane where the release requires them: ```sh npx three-blocks shaders npx three-blocks shaders test --skip-browser --mode strict ``` The `shaders capture` batch fallback starts the selected Vite, static, or attached driver for each configured backend and writes `.three-blocks/shaders/..ts` plus the matching public JSON manifest. It replaces `meta.json` last as the commit marker. Its terminal receipt reports the measured startup change: `TSL builds at startup: N → 0 · ≈X ms TSL work avoided (single-capture estimate)`. ### Generate text atlases before runtime Multi-channel signed distance field (MSDF) text needs a glyph atlas and per-glyph metrics. Preparing those files before release avoids runtime atlas rasterization; built-in routes also ship the pinned browser WOFF2 instead of the authoring TTF. Declare your fonts, their public routes, and the content that contains visible text: ```ts file=three-blocks.text.ts import { defineText } from "three-blocks/text"; export const textConfig = defineText({ content: ["index.html"], fonts: { geist: { source: { builtin: "geist-sans" }, browser: "/fonts/geist.woff2", atlas: "/fonts/geist.msdf.ktx2", metrics: "/fonts/geist.msdf.json", families: ["Geist Sans"], default: true, }, }, }); ``` Pass that same object to the Vite plugin so it can report text state and watch the declared content: ```ts file=vite.config.ts import { defineConfig } from "vite"; import { threeBlocks } from "three-blocks/vite"; import { textConfig } from "./three-blocks.text"; export default defineConfig(({ mode }) => ({ plugins: [threeBlocks({ shaders: { strict: mode === "strict" }, text: { configuration: textConfig }, })], })); ``` Run `npx three-blocks text generate`. The command scans the declared content and rasterizes only the code points it finds. It writes the configured browser-font copy, a compressed `.msdf.ktx2` atlas, `.msdf.json` metrics, and a receipt under `public/` (the routes above use `public/fonts/`). Built-ins provide a pinned browser WOFF2; `path` and `package` sources copy their supplied font bytes unchanged. [MSDF Text](/docs/blocks/msdf-text) consumes the atlas and metrics. With `text.configuration` wired as above, the Vite plugin watches declared content and regenerates the files when new glyphs appear during development. ### Bake environment lighting before runtime Run `npx three-blocks environment bake` to render and prefilter the room environment once. The command writes a compressed KTX2 cube that loads as finished lighting, so the first frame does not run `PMREMGenerator`. ### Optimize models and textures to GPU-compressed formats Run `npx three-blocks optimize` on any GLB, texture, or HDR environment — or just capture: the CLI shader capture optimizes every `public/` GLB and `.hdr` source automatically after the scenes commit. GLB geometry is rewritten with meshopt, textures encode slot-aware to Basis Universal KTX2 (sRGB color, linear normal and data), and HDR environments become UASTC HDR that transcodes to BC6H on capable GPUs with an RGBA16F fallback elsewhere. Every run records exact per-mip download and VRAM numbers in the `.three-blocks/assets/meta.json` receipt, the development overlay shows the current state, and `npx three-blocks assets status` re-verifies it in CI. ## Run devtools commands Use one namespace for every command: | Command | Result | |---|---| | `npx three-blocks status` | Report worker, asset, shader, and text state | | `npx three-blocks doctor` | Diagnose package, project, credential, Blender-hub, and optional engine state without changing assets | | `npx three-blocks shaders` | Verify shader freshness without a browser or GPU; exit non-zero with the recovery command when stale | | `npx three-blocks shaders status --check` | Print the detailed per-scene freshness report and return its CI exit code | | `npx three-blocks shaders capture --if-stale` | Batch/CI fallback: drive registered routes for configured backends when inputs changed | | `npx three-blocks shaders test --skip-browser --mode strict` | Check schema and freshness without a browser or GPU | | `npx three-blocks shaders test` | Assert zero registered live builds and compare live and precompiled pixels | | `npx three-blocks shaders watch` | Recapture while shader inputs change | | `npx three-blocks text generate` | Build MSDF atlases, metrics, browser-font copies, and receipts | | `npx three-blocks text status` | Verify text assets and glyph coverage | | `npx three-blocks environment bake` | Bake a prefiltered environment KTX2 | | `npx three-blocks optimize` | Compress GLB, texture, or HDR inputs to meshopt + KTX2 with exact size and VRAM accounting | | `npx three-blocks assets status` | Re-verify the optimized-asset receipt; exit non-zero when sources drifted | | `npx three-blocks browser smoke` | Exercise readiness and app behavior in a headless browser | | `npx three-blocks browser preview` | Verify the production preview | Commands support `--json` and `--reporter json` for CI. During ordinary development, capture the current scene from the overlay; `shaders capture` is the explicit batch fallback and also keeps public GLB and HDR assets optimized. Browser work resolves optional `playwright` and `vite` packages only when the selected command needs them; install Playwright and its Chromium build on capture machines. Add `--backend webgpu`, `--backend webgl`, or `--backend both` to select a lane. A built-in font downloads once into a checksum-verified user cache; prewarm that cache or use a `path` or package source before a first offline text build. Capture needs a machine that supports the selected backend. Commit artifacts and verify them in CI instead of capturing there. ## Ship it Commit `.three-blocks/shaders/` and the generated public manifests. Add one GPU-less CI line: ```sh npx three-blocks shaders test --skip-browser --mode strict ``` A missing, stale, or invalid artifact exits non-zero. Add `--reporter json` for CI annotations. The optional GPU lane runs full `shaders test`. Prefer capturing once on a development machine and verifying the committed result in parallel CI jobs; if CI captures, run only one capture writer per checkout. Production serves the committed manifests. Overlay and stats code erase through the production export condition, while hydration remains. With `stats: { production: true }`, the app prints one local receipt such as `precompiled: 14 shaders, 0 live builds`; no vendor telemetry is sent. ## Choose the configuration file you need Each configuration file has one reader and lifecycle: | File | Add it when | Read by | |---|---|---| | `three-blocks.shaders.json` | You precompile shaders | Capture commands and the Vite plugin | | `three-blocks.text.ts` | You render MSDF text | Text commands and runtime; pass its exported configuration to the Vite plugin | | `three-blocks.json` | Never in an adopted app; the starter generates it | Starter status and ownership tooling | | `three-blocks.artifacts.json` | You publish generated release artifacts | Artifact verification tooling | ## Troubleshoot devtools - **The overlay reports `shaders live`.** Nothing may be registered, capture may not have run, or a semantic input changed. Click **Capture shaders** for the current scene, or run `npx three-blocks shaders` to list the state and recovery command. - **Capture fails on a new machine.** Run `npx playwright install chromium`, then confirm that the machine exposes the selected backend. Capture on a development machine and commit the artifacts. - **The Performance toggle does not open panels.** Add the optional panel dependency with `bun add -d stats-gl`. - **Everything becomes stale after upgrading the Three Blocks package.** Captures pin the runtime that created them. Capture the open scene from the overlay, or run `npx three-blocks shaders capture` once for the complete matrix, then commit the new artifacts. - **The app uses standalone `WebGLRenderer`.** Devtools supports the `WebGPURenderer` WebGL fallback, not the separate legacy renderer; the app continues to build shaders live. ## License boundary The devtools runtime in the core package and the `@three-blocks/devtools` command engine use PolyForm Noncommercial 1.0.0. Personal and noncommercial projects can use them without an account or runtime gate. Commercial projects use the Pro [license](/license). ### Gaussian splat pipelines Canonical: https://threejs-blocks.com/docs/tools/gaussian-splat-pipeline The Mesh to Splat add-on and CLI share one production pipeline for stills and animated 4D Gaussian captures. Choose a subject, choose Still or Animation, and run one command or one Blender button; camera setup, synchronized renders, training, encoding, and validation are automatic. ## Static capture ```sh npx three-blocks tools splat scene.blend --object Hero --quality high -o public/splats ``` Static mode captures the current frame and writes canonical PLY, stable-ID sidecars, and SOG when the converter is available. ## Animated 4DGS capture ```sh npx three-blocks tools splat scene.blend --object Hero --animation -o public/splats ``` Animation mode uses the Blender scene's start, end, step, and frame rate by default. It scans the full motion bounds before placing one camera rig, samples one canonical triangle/barycentric identity table, renders every frame from the same synchronized views, trains the sequence with brush-spacetime, and writes: - `Hero.b4dgs`: gzip temporal container; - `Hero.b4dgs.json`: source frames, settings, dynamic/static groups, quantization, and measured round-trip errors; - cached `frame_####` COLMAP captures for retraining. Frame PLYs are removed after a successful encode because they can be very large. Enable Keep Frame PLYs in Blender or the corresponding CLI option only when you need to re-encode without retraining. 4D identity requires stable object names, vertex order, and polygon topology. Armatures, shape keys, cloth, and topology-preserving modifiers are supported. Topology-changing Geometry Nodes or remeshing fail before training with the offending object and frame. ## Artifact boundary Treat the static and spacetime engine binaries, capture frames, correspondence plan, `.b4dgs`, and its validation report as one release unit. The encoder tests position, scale, opacity, rotation, and color independently; it stores a group once only when every frame is invariant at the chosen quantization. ## Before runtime integration Keep source, settings, tool version, report, and generated media on one immutable revision. Static PLY/SOG output loads through `GaussianSplats`. The `.b4dgs` file is the validated authoring interchange; convert it to the browser SplatClip video tier for animated delivery. In the repository, the existing video exporter owns that authoring step: ```sh bun run --cwd packages/three-blocks splat:video -- frames/clip_*.ply --out public/splats/clip ``` The command validates the serialized result before writing it. Browser code loads the generated manifest with `SplatClip`; `packSplatVideo` is intentionally not a runtime package export. ### Object Animation Video exporter Canonical: https://threejs-blocks.com/docs/tools/object-animation-video Bake stable rigid-object names, parents, and affine transforms into a versioned OAV package. ## Export ```sh three-blocks tools oav scene.blend --out sculpture.oav ``` The exporter writes OAV version 2, the current public schema. Object transforms use one exact indexed-meshopt UTSBM track, so numerical export does not invoke FFmpeg and has no media codec, QP, tile-size, or encoder-preset setting. ## Artifact boundary Use strict runtime binding and regenerate the manifest and numerical track together whenever hierarchy, timing, or quantization changes. The `.utsbm` blocks are decoded to typed transform data before Three.js uploads changed instance or batch buffers; they are not read by the GPU directly. ## Before runtime integration Keep source, settings, tool version, manifest, and generated tracks on one immutable revision. Use the linked runtime block for browser initialization, update order, and disposal. ### Three Blocks CLI Canonical: https://threejs-blocks.com/docs/tools/three-blocks-cli Keep the project package and CLI on the same pinned version for status, doctor, text, shader, starter, and authoring workflows. ## Test the current alpha ```bash npm i three-blocks@alpha three npx three-blocks@alpha login npm create three-blocks-starter@alpha ``` The alpha CLI identifies itself in the banner, uses the preprod site for auth and tool downloads, and does not send production telemetry. `--site` or `TB_SITE_URL` still overrides its stamped origin. ## Artifact boundary Run doctor before changing assets; credentials remain local and generated artifacts never contain them. ## Before runtime integration Keep source, settings, tool version, manifest, and generated media on one immutable revision. Use the linked runtime block for browser initialization, update order, and disposal. ### Vertex Animation Video exporter Canonical: https://threejs-blocks.com/docs/tools/vertex-animation-video Bake stable-topology positions, normals, and optional appearance into VAV interchange and versioned runtime tracks. ## Export ```sh three-blocks tools vav clip.vavbake --out cloth.vav ``` The exporter writes VAV version 2, the current public schema. Numerical geometry and per-vertex appearance use exact indexed-meshopt UTSBM tracks. Optional UV-space visual appearance remains a media track and keeps its UV quality controls. ## Artifact boundary Check topology and vertex order across the full clip; keep geometry, appearance, quantization, `base.bin`, and manifest revisions synchronized. The runtime reconstructs `.utsbm` block lanes into two R8 texture slots before Three.js uploads them; the GPU does not consume the container directly. ## Before runtime integration Keep source, settings, tool version, manifest, and generated tracks on one immutable revision. Use the linked runtime block for browser initialization, update order, and disposal. ### Build a website with the starter Canonical: https://threejs-blocks.com/docs/tutorials/build-a-website-with-the-starter Build a four-section website where branded shapes respond to scrolling while readable HTML carries the story. Start from the finished Website template, then make the composition yours in `src/scene.ts`. ## Open the finished starting point Run the starter and choose **Website**: ```sh npx three-blocks starter ``` Run the directory and development commands printed at the end, then open `http://localhost:4000` unless Vite reports another port. Scroll through the untouched result, then open `src/scene.ts` and change one shape's color. The canvas should update without losing its current scroll position. ## Keep the application boundaries stable The template already keeps the renderer in a worker, lets the DOM own scroll and meaning, and swaps the visible scene without restarting the whole application. Your work is the story, visual system, and choreography. The boundary is intentionally small: - `index.html` owns semantic sections and calls to action; - `src/main.ts` owns DOM input, Lenis, and the worker host; - `src/render.worker.ts` owns WebGPU and the frame loop; - `src/scene.ts` owns the visible world you will art-direct. Keep those owners stable. A framework can mount this host, but it should not reconstruct a renderer when component state changes. ## Set one visual system Start with the still frame. Use one quiet stage, one designed light rig, and the gold, red, and blue brand primaries. The three shapes need different silhouettes and material response before they move. Avoid adding postprocessing to repair an unclear composition. Every material that can produce a shader must remain registered through a literal scene-context call. That explicit inventory is how capture proves it did not miss a pipeline. Dispose the same material instances when the scene owner is removed. ## Choreograph four sections Write four short DOM sections first: the visual premise, the worker proof, the precompiled-shader release proof, and the invitation to make it yours. Map their normalized scroll range to one worker-side timeline. A single timeline makes triangle → circle → square motion testable. It also keeps wheel, touch, keyboard, and programmatic scroll on the same path. A deliberate main-thread block is the sharper ownership test: the DOM pauses briefly while the worker canvas keeps moving. The canvas is enhancement, not the only carrier of meaning. Headings, links, and the proof statement remain readable when WebGPU is unavailable or reduced motion is requested. ## Capture and deploy While materials are changing, `shaders live` is honest and safe. Once their semantic inputs settle, run the capture and strict build commands from the final milestone. Commit the shader payload and receipt together, then open the production preview. The strict build proves the capture is fresh. It does not ship the overlay: only `vite build --mode demo` keeps shaders strict *and* keeps the overlay and stats meter in the output. Preview that build, and the readiness badge should reach **Ready** while the shader hero reports **Shaders precompiled** with the latest TSL build timing. Continue with [Precompiled shaders](/docs/concepts/precompiled-shaders) when a receipt becomes stale, or [Devtools](/docs/tools/devtools) when ownership or readiness is unclear. ### Your first Three Blocks scene: a product hero Canonical: https://threejs-blocks.com/docs/tutorials/first-product-hero Build one production-shaped result: a refractive product object with a controlled camera, bounded device-pixel ratio, responsive sizing, explicit disposal, and a useful static fallback. You will finish with the mental model for where Three Blocks joins a Three.js renderer lifecycle. Allow about 25 minutes. You need basic Three.js scene knowledge, Node.js 22.12 or later, and a WebGPU-capable browser. ## Scaffold the scene Generate the supported scene template, install its locked dependencies, and run the production build before changing the visual. The checkpoint is concrete: one canvas, one frame loop, and a clean build. ## Shape the product hero Create [Transmission](/docs/blocks/transmission) only after renderer initialization. Tune thickness before opacity and keep geometry and material under one disposable owner. Compare your result with the [working example](/examples/webgpu_material_transmission). ## Own the lifecycle Cap DPR, resize camera and renderer together, update and render from one frame owner, then stop the loop before disposing resources. If the canvas only works after hot reload, revisit [WebGPU renderer initialization](/docs/concepts/webgpu-initialization). ## Ship a useful fallback Keep the approved poster, product name, description, and primary action in HTML. Hide the poster only after the live frame is ready. The fallback communicates the product; it does not need to imitate the renderer. ## Production checklist - Initialize WebGPU before GPU-backed blocks. - Cap DPR and resize against the actual container. - Give the loop and every listener one cleanup path. - Dispose geometry, material, and renderer after producers stop. - Preserve the product message and action without WebGPU. - Keep starter, finished code, and displayed versions on the same revision. Continue with [Direct an interactive product cinematic](/docs/tutorials/interactive-product-cinematic) or review [Lifecycle and disposal](/docs/concepts/lifecycle-and-disposal). ### Direct an interactive product cinematic Canonical: https://threejs-blocks.com/docs/tutorials/interactive-product-cinematic Turn an approved camera render into a pointer-responsive presentation with a controlled rest state, whole-file ActiveFrame delivery, and a poster fallback. The goal is to choose a baked representation deliberately and own its decoder and render lifecycle as carefully as a live mesh. Allow about 50 minutes. You need a Baked Motion manifest, WebGPU, WebCodecs, and familiarity with the first tutorial's lifecycle. ## Load the authored shot Initialize the renderer, then construct [Baked Motion](/docs/blocks/baked-motion) with that renderer. Wait for readiness before adding the mesh. Keep the HTML poster above the canvas throughout this work. If startup requests a pointer or camera sample, await the resulting `frameReady`, render once, and only then hide the poster. ```js await renderer.init(); const motion = new BakedMotion("/product/tilt.utsbv/manifest.json", { renderer }); await motion.ready; ``` Catch `BakedMotionError` and show its stable `code` in a local status region. Keep the immutable diagnostic snapshot behind a details control so a failed resource, whole-file byte budget, or decoder candidate can be inspected without turning browser hardware information into telemetry. A missing manifest, unsupported decoder group, failed integrity check, or GPU upload must leave the poster visible rather than an empty canvas. ## Map pointer intent Normalize pointer position against the canvas, store the latest request, and let the animation loop own sampling. Event handlers must not perform decode or render work. ## Direct the rest state Run a small authored idle curve only when the pointer is absent. Read `prefers-reduced-motion` before initializing WebGPU or fetching the manifest; reduced motion keeps the composed poster and skips the Baked Motion instance. Compare the transition with the [working pointer-tilt example](/examples/webgpu_baked_motion_tilt). ## Bound streaming and cleanup Keep the poster until the requested frame is ready. Suspend the motion when the document is hidden or the stage leaves the viewport; resume only the active stage and catch re-admission failure by restoring the poster. On unmount, stop the loop, disconnect visibility and resize observers, remove pointer listeners, then dispose [ActiveFrame Video](/docs/blocks/active-frame-video), Baked Motion, and the renderer. ## Production checklist - Confirm the captured camera envelope matches the approved shot. - Keep the poster until a requested frame is ready. - Keep the composed poster and skip decoder work when reduced motion is enabled. - Display typed state and error codes; keep detailed diagnostics local. - Suspend hidden/offscreen motion and catch resume failures. - Verify the selected rendition and complete `.af` byte budget on target devices. - Budget DPR, decoder buffers, and fallback media together. - Preserve the product action without WebGPU or WebCodecs. - Dispose loops, observers, listeners, decoders, motion, and renderer. Continue with [Art-direct a pointer-reactive atmospheric effect](/docs/tutorials/stylized-pointer-vfx) or review [Streaming versus preloading](/docs/concepts/streaming-versus-preloading). ### Populate a large interactive world Canonical: https://threejs-blocks.com/docs/tutorials/large-interactive-world Sample a terrain on the GPU, cull invisible instances before shading, and keep interaction and diagnostics bounded as the world grows. The finished result keeps transforms GPU-owned from population through drawing. Allow about 70 minutes. You need InstancedMesh and node-material experience, an understanding of GPU storage, and a WebGPU browser. ## Keep transforms on the GPU Choose a maximum instance capacity, let [Surface Sampling](/docs/blocks/surface-sampling) own the transform storage, and connect that storage directly to the instance mesh. Avoid the CPU readback-and-upload round trip. ## Sample the world Use dynamic sampling only for a surface whose positions actually change. Reproject pointer NDC through the camera into a world-space center, set a radius around that 3D lens, and run geometry deformation before the sampler reads it. ## Cull before shading Use [Instance Culling](/docs/blocks/instance-culling) before custom deformation and material work. Preserve source identity through the culling index. Reach for [Indirect Batching](/docs/blocks/indirect-batching) when visible survivors use different geometries. ## Bound interaction and readback Publish the latest interaction center before compute and render without awaiting a count. The [sampled and culled flock example](/examples/webgpu_simulation_boids_3d) keeps its initial placement, flocking, and visible-survivor draw work on the GPU, making the absence of a per-frame readback loop visible rather than implicit. ## Production checklist - Name instance capacity as a memory and draw budget. - Share GPU-owned transforms without per-frame CPU copies. - Run geometry, sampling, and culling before render. - Update interaction without rebuilding population. - Throttle diagnostic readbacks outside the critical path. - Dispose culler and sampler before mesh, material, geometry, and renderer. Return to [Tutorials](/docs/tutorials), or review [Storage buffers and GPU ownership](/docs/concepts/gpu-ownership). ### Art-direct a pointer-reactive atmospheric effect Canonical: https://threejs-blocks.com/docs/tutorials/stylized-pointer-vfx Build a stylized smoke volume, inject pointer movement as a world-space force, and expose a coherent quality ladder. You will finish with an explicit pipeline: interaction, fixed simulation steps, volume render, then composite. Allow about 75 minutes. You need Three.js raycasting and render-target experience plus a WebGPU browser. ## Name the quality ladder Define desktop and mobile tiers before allocating [Smoke](/docs/blocks/smoke). Scale grid resolution, light steps, compositor scale, and DPR together. A static atmospheric frame remains the useful floor. ## Initialize the volume Initialize WebGPU first, then create the volume with a stable set of dissipation, buoyancy, and pressure controls. Shape emitters and lighting before multiplying solver settings. ## Inject pointer motion Raycast onto a world-space surface, derive a bounded velocity from successive points, and queue the input for the next simulation step. Event frequency must not determine compute submission frequency. ## Step before composite Cap the fixed-step accumulator, complete simulation before rendering its result, and dispose the compositor and volume only after the animation loop stops. Use the [working smoke example](/examples/webgpu_simulation_smoke_3d) as the visual checkpoint. ## Production checklist - Scale simulation, lighting, compositing, and DPR as one tier. - Publish bounded world-space input from pointer events. - Finish simulation before the render that consumes it. - Cap fixed-step catch-up work. - Preserve a still for reduced motion and non-WebGPU devices. - Dispose compositor, textures, scene resources, listeners, and renderer. Continue with [Populate a large interactive world](/docs/tutorials/large-interactive-world) or review [Compute before render](/docs/concepts/compute-before-render) and [Performance ladders](/docs/concepts/performance-ladders). ## Create guides ### Product visualization Present an object with convincing material, motion, detail, and interaction while keeping payload and runtime costs predictable. Canonical: https://threejs-blocks.com/docs/create/product-visualization Representative blocks: transmission, baked-motion, gaussian-splats. - Does lighting or geometry need to react independently? Keep a live mesh and material when either response must change outside a controlled camera path. Tradeoff: The browser pays geometry, lighting, and shading costs every frame. - Is the approved rendered image more important than free camera movement? Use Baked Motion when interaction can stay within captured timeline, tilt, or rotation dimensions. Tradeoff: Art direction stays intact, but viewpoints and lighting are limited to authored samples. - Is the source a captured object or space rather than a clean production mesh? Use Gaussian splats when capture preserves detail that would be expensive to rebuild. Tradeoff: Sorting, memory, and fallback behavior need explicit device budgets. ### Interactive experiences Make a scene respond to people, layout, motion, and spatial content without turning it into an unmaintainable demo. Canonical: https://threejs-blocks.com/docs/create/interactive-experiences Representative blocks: msdf-text, gpu-interaction, instance-culling. - Can the glyph set be baked before deployment? Use MSDF Text for planned interface and spatial typography. Tradeoff: A baked atlas is predictable and cheap, but genuinely unknown glyphs need another path. - Will many objects share the same interaction state? Publish interaction through GPU Interaction instead of copying pointer or collider state into each system. Tradeoff: Shared layouts reduce duplication but make update order an explicit contract. - Does the scene contain more instances than the camera can show? Sample and cull in GPU memory before investing in more detailed shading. Tradeoff: Indirect data flow is efficient at scale and harder to inspect than CPU-owned transforms. ### Visual effects Add atmosphere, physical behavior, and an art-directed image without hiding the render pipeline or cost required to ship it. Canonical: https://threejs-blocks.com/docs/create/visual-effects Representative blocks: smoke, water, core-tsl-effects. - Does the effect need a physical volume or only an image treatment? Use a volume simulation when objects and camera depth must interact with the effect; use a TSL image treatment for screen-space motion. Tradeoff: Volumes add grid memory, simulation passes, and compositing work that a 2D treatment avoids. - Do you need stable incompressibility, force-driven behavior, or material deformation? Start with PBF, SPH, or MPM respectively, then validate the choice against the interaction and scale. Tradeoff: Each solver exposes a different stability, tuning, memory, and compute profile. - Does particle count make hardware sphere geometry the bottleneck? Use sphere impostors when one-triangle particles preserve the required lighting and depth response. Tradeoff: Impostors reduce vertices but move silhouette, depth, and anti-aliasing work into shading. ## Examples ### Spotlight Type A four-section Three.js website keeps semantic DOM copy synchronized with batched text from a pre-generated MSDF atlas as the page scrolls. A fragment shader gives every glyph the same cone, penumbra, and inverse-square decay as the pointer-reactive SpotLight illuminating the rough PBR wall, while the browser remains responsible for layout, selection, responsiveness, and accessibility. Canonical: https://threejs-blocks.com/examples/webgl_text_input Renderer: webgl; techniques: none classified. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/msdf-text. ### Smoke Post-Processing Screen-space fluid postprocessing warps the final image with a 2D smoke sim. A spinning cube cluster is rendered to a pass, the smoke node evolves on top using pointer input for splats, and post uniforms control distortion, blend, and tint. Canonical: https://threejs-blocks.com/examples/webgl_postprocessing_smoke Renderer: webgl; techniques: none classified. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/smoke. ### SDF Body Tracking — Ball Pit Michelle samba-dances through a glossy 16,384-ball MLS-MPM pit until MediaPipe finds you, then the clip stops and her calibrated T-pose becomes the base for live skeleton retargeting. Upper-body-only tracking lowers her into reach of the balls, while a live signed-distance and surface-velocity texture turns her skinned mesh into their moving collider. Canonical: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking Renderer: webgpu; techniques: SDF, MPM. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences, https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/sdf-raymarching, https://threejs-blocks.com/docs/blocks/gpu-interaction, https://threejs-blocks.com/docs/blocks/mpm, https://threejs-blocks.com/docs/blocks/sphere-impostors. ### Ocean · Raymarched Volume Water A 524,288-particle MLS-MPM/APIC ocean spans a 44×22 m surface and transfers mass and momentum through a 128×64×64 grid. WaterVolume supplies dispersion-matched crossing swell, hydrostatic seeding, an absorbing rim, pointer splashes, and GPU whitewater sourced from the fluid's velocity gradient; WaterRayMarchRenderer presents it as a continuous volume with trilinear traversal, reconstructed depth and normals, water-column shadows, bounded absorption, PMREM reflections, crest scattering, and simulation-fed foam. Canonical: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean Renderer: webgpu; techniques: MPM, Raymarching. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/water. ### Ocean · Software-Compute Water A 524,288-particle MLS-MPM/APIC WaterVolume ocean keeps the raymarched flagship's simulation, crossing swell, absorbing rim, pointer splashes, and whitewater, but renders its particles through ComputeSphereRasterizer. The software pipeline bins spheres into 16×16 screen tiles and logarithmic depth slices, resolves the nearest hit without atomics, and writes true depth and normals for scene lighting and GTAO. Around the water stands the Hokusai scenography of the fluid experience Utsubo built for World Expo 2025, Osaka — the Great Wave and Mount Fuji as instanced dot clouds, drifting prop clouds, birds, and three buoyant boats riding SurfaceField probes — under the installation's static camera, lighting, and color grade (reference: the utsuboco/fluid electron branch). Canonical: https://threejs-blocks.com/examples/webgpu_simulation_water_compute Renderer: webgpu; techniques: MPM, Compute. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/water, https://threejs-blocks.com/docs/blocks/sphere-impostors. ### Text MSDF Wall Inspired by Utsubo’s official interactive installation for SMRJ at Expo 2025 Osaka, Kansai, this wall recalls 1,800 company messages brought to life through generative motion and typography across three projection screens. Six hundred forty English and Japanese Three Blocks terms fill two moving screen-space layers in one instanced draw call, with a center-born pulse and three curved, noise-warped TSL light waves flowing continuously in Blocks yellow. Canonical: https://threejs-blocks.com/examples/webgpu_text_msdf_batched Renderer: webgpu; techniques: MSDF. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/msdf-text. ### 3D Smoke Simulation GPU smoke rises from a dying campfire in a procedural LoftGeometry forest with no fetched assets. A scaled depth prepass keeps the low-resolution volume compositing clean around trees, while pointer gusts stir the plume and a shallow fog bank even as the camera orbits. Canonical: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d Renderer: webgpu; techniques: none classified. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/smoke, https://threejs-blocks.com/docs/blocks/runtime-sdf-text, https://threejs-blocks.com/docs/blocks/sdf-raymarching. ### Baked Motion · Camera Grid A 19 × 19 camera grid loads one verified 768px albedo file into four bounded texture slots — and skips the depth track entirely when reprojection is off. BakedMotion follows an ambient path until pointer input takes control and directly blends the four neighboring tilt views. A restrained HUD maps the stored cameras and current blend without requiring the original model or material graph. We generated this asset with Baked Motion, a Pro add-on available with the commercial license. Canonical: https://threejs-blocks.com/examples/webgpu_baked_motion_tilt Renderer: webgpu; techniques: Baked Motion. Create paths: https://threejs-blocks.com/docs/create/product-visualization, https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/baked-motion, https://threejs-blocks.com/docs/blocks/active-frame-video, https://threejs-blocks.com/docs/blocks/transmission. ### Baked Motion · 360° Turn An explicit angular velocity advances the camera around a compressed 361-view turntable — an AV1 rendition over an H.264 floor — then BakedMotion.setView() maps its azimuth. Wheel input raises that velocity before it decays to the baseline, while direct pointer events handle drag. The HUD gives every stored angle its own tooth, highlights the bracketing views, and separates the duplicated 360° seam. The depth-aware billboard ships without the original model or material graph. We generated this asset with Baked Motion, a Pro add-on available with the commercial license. Canonical: https://threejs-blocks.com/examples/webgpu_baked_motion_rotation Renderer: webgpu; techniques: Baked Motion. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/baked-motion, https://threejs-blocks.com/docs/blocks/active-frame-video, https://threejs-blocks.com/docs/blocks/transmission. ### Relit Gaussian Splats A cactus SplatMesh uses compute-tile lighting to reconstruct hybrid normals and respond to an HDR environment, a shadow-casting directional light, and warm/cool point lights that orbit the capture. A metallic torus and torus knot share the dark stage as conventional PBR references. The compact default controls switch between relit and captured color, while buffer and normal views stay behind ?debug. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_lit Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats. ### 4D Gaussian Capture A fixed-topology temporal Gaussian reconstruction trained from 26 synchronized synthetic studio views preserves an oversized garment’s seams, drape, and changing folds across 46 frames. The delivery tier retains all 150,000 anisotropic splats, inflates independently seekable 82-bit packed geometry, and decodes high-quality H.264 appearance into one orbitable resident mesh. After the first lap, a budget-gated GPU cache makes loops and scrubs decode-free; a slow auto-orbit frames the capture, and holding an orbit drag eases time to 5% for a bullet-time inspection of any instant. Runtime telemetry reports decode margin, cache residency, upload, unpack, projection, and sort timing. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_4dgs_video Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats. ### Gaussian Splatting Visualizer Interactive drag & drop visualizer for testing 3D Gaussian Splatting models. Drop .ply, .splat, or .splats files to preview them with real-time controls for visualization modes, spherical harmonics, and material settings. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats, https://threejs-blocks.com/docs/blocks/grid-pristine. ### Living Glass MeshTransmissionNodeMaterial turns a rounded glass vessel into the refractive boundary for 8,192 live PBF particles, whose instanced spheres brighten from gray to gold with velocity. A blurred Ninomaru garden HDR lights both the fluid and the rotating vessel. The hero controls expose turntable speed, fluid speed, glass frost, and prism fringe; the full material and PBF controls stay behind ?debug. Canonical: https://threejs-blocks.com/examples/webgpu_material_transmission Renderer: webgpu; techniques: none classified. Create paths: https://threejs-blocks.com/docs/create/product-visualization, https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/transmission, https://threejs-blocks.com/docs/blocks/pbf. ### Bunny-Shaped Flock Boids, ComputeBVHSampler, an SDF volume constraint, and ComputeInstanceCulling compose a dense flock inside a bunny-shaped volume. BirdGeometry instances bank and flap from the surviving culled indices while the spatial grid keeps flocking fast; a sky stage and restrained bird palette replace the old debug-grid presentation. Canonical: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d Renderer: webgpu; techniques: Boids, Culling. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/boids, https://threejs-blocks.com/docs/blocks/sdf-raymarching, https://threejs-blocks.com/docs/blocks/surface-sampling, https://threejs-blocks.com/docs/blocks/instance-culling. ### Liquid Bunny · SPH / PBF One bunny-shaped particle scene switches between the SPH and PBF solvers for a direct fluid-behavior comparison. Both modes start from the same ComputeBVHSampler positions and share SDFVolumeConstraint containment, pointer interaction, velocity shading, one-triangle sphere-impostor nodes, ComputeInstanceCulling, and indirect drawing, so only the solver changes. Canonical: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d Renderer: webgpu; techniques: SPH, PBF. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/sph, https://threejs-blocks.com/docs/blocks/pbf, https://threejs-blocks.com/docs/blocks/sphere-impostors, https://threejs-blocks.com/docs/blocks/sdf-raymarching, https://threejs-blocks.com/docs/blocks/surface-sampling, https://threejs-blocks.com/docs/blocks/instance-culling, https://threejs-blocks.com/docs/blocks/core-tsl-effects. ### Text on a Skinned Surface ComputeMeshSurfaceSampler resamples 8,000 transforms and normals from Michelle's SambaDance surface at every animated pose. One instanced quad batch reads the sampler's storage buffer and a prebuilt Noto Sans JP MSDF atlas directly, so the warm Hiragana figure mirrors the visible dancer with no runtime glyph generation or CPU readback. Hero controls cycle between Hiragana and digits, adjust the body/type gap, and hide the source silhouette; billboard orientation stays behind ?debug. Canonical: https://threejs-blocks.com/examples/webgpu_text_sampler_skinned Renderer: webgpu; techniques: MSDF. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/runtime-sdf-text, https://threejs-blocks.com/docs/blocks/surface-sampling, https://threejs-blocks.com/docs/blocks/msdf-text, https://threejs-blocks.com/docs/blocks/core-tsl-effects. ### Object Animation Video ObjectAnimationVideo binds smoothly interpolated authored transforms from one exact UTSBM transform track (one block-indexed meshopt asset) to a 361-part GLTF sculpture while geometry, materials, camera response, and culling remain live. The numerical path creates no video decoder. Streamed batch keeps every rigid part active in a standard BatchedMesh, while the default GPU-driven mode uses IndirectBatchedMesh to compact visible parts and issue one indirect batch. We generated this asset with Object Animation Video, a Pro add-on available with the commercial license. Canonical: https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect Renderer: webgpu; techniques: none classified. Create paths: https://threejs-blocks.com/docs/create/product-visualization, https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/object-animation-video, https://threejs-blocks.com/docs/blocks/indirect-batching. ### GPU-Driven City · Integration Showcase This production-style city combines heterogeneous geometry pooling, GPU-authored transforms, an endless ring, and textured materials. Three Blocks IndirectBatchedMesh and Three Blocks GPU culling compact per-geometry survivors into one render item with eight indirect commands; native BatchedMesh, eight InstancedMesh pools, and individual Mesh objects remain educational integration controls. Use The Brick Room for a physics-driven transform and pointer-interaction integration. Canonical: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh Renderer: webgpu; techniques: Culling, Compute. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/indirect-batching. ### The Brick Room · 131K GPU Toy Physics A kid’s-eye playroom fills as 131,072 colorful toy bricks rain from ceiling lanes into a frictional Three Blocks MLS-MPM/APIC pile. One Three Blocks IndirectBatchedMesh keeps every tumbling pose and three-tier geometry LOD on the GPU, while the internal culler re-buckets eight archetypes across 24 indirect commands in one render item. Switch to the overview camera, stir or blast the pile, or press BUILD to spring 32,928 pieces into a hovering giant brick. Canonical: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility Renderer: webgpu; techniques: Culling, MPM. Create paths: https://threejs-blocks.com/docs/create/interactive-experiences. Curated blocks: https://threejs-blocks.com/docs/blocks/indirect-batching, https://threejs-blocks.com/docs/blocks/instance-culling, https://threejs-blocks.com/docs/blocks/mpm. ### Points → Volume GaussianSplatsPoints extracts the cactus capture's point positions, PointsBVH accelerates nearest-point queries, and ComputePointsSDFGenerator bakes a flood-filled 128³ signed-distance field with an automatically derived shell radius. RayMarchSDFNodeMaterial measures view and light paths through that field, then layers an analytic studio, softened two-lobe scattering, refracted exit radiance, field-local clouds and veins, dual GGX polish, and AgX output over the unchanged thickness transport. Shape, material-preset, story, and quality controls compare the scan with a procedural cabochon and expose the source splats and volume slices without generating a mesh. Canonical: https://threejs-blocks.com/examples/webgpu_points_bvh_volume Renderer: webgpu; techniques: BVH, SDF, Raymarching. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/sdf-raymarching, https://threejs-blocks.com/docs/blocks/gaussian-splats. ### Baked Motion · Timeline Seconds 1:36–1:51 of THE ODYSSEY (2026) trailer temporarily play at native 2060×1440 on a GT-class 1.43:1 giant screen inside a 3D stadium-raked auditorium, with no crop or upscale. BakedMotion streams verified 2K and 1030px H.264 renditions through WebCodecs via opt-in byte-range segments, with its resident H.264 proxy as the fallback. A cinema-style transport cycles 0.5×, 1×, 2×, and 3× playback and seeks any authored frame directly from its notched progress rail. Source: youtube.com/watch?v=sUtBLbDYdB4. Big Buck Bunny remains the intended long-term footage. Canonical: https://threejs-blocks.com/examples/webgpu_baked_motion_timeline Renderer: webgpu; techniques: Baked Motion. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/baked-motion, https://threejs-blocks.com/docs/blocks/active-frame-video. ### Vertex Animation Video · Laundry Sheet A Blender cloth simulation of a pinned laundry sheet streams through VAVMesh as an exact UTSBM geometry track: 16-bit positions plus octahedral normals for 11,968 vertices × 250 frames at 24 fps in meshopt-coded block assets (~6.2 MB Brotli on the wire), streamed progressively from one block-indexed asset into two R8 atlas slots. The clip drives a physically-based sheen material that keeps live lighting, soft shadows, and orbit control; the exporter crossfades the loop seam away, and a wireframe toggle exposes the deforming mesh. Canonical: https://threejs-blocks.com/examples/webgpu_vav_basic Renderer: webgpu; techniques: VAV. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/vertex-animation-video. ### Gaussian Splat Morph Three Mesh to Splat captures share the same exact splat count, seed, origin, and scale: a yellow triangular prism, red sphere, and blue box. The runtime validates count and spherical-harmonic compatibility, pairs splats one-to-one through an octahedral-Morton angular rank, keeps the prism as its resident source, and packs both targets plus their available SH bands and per-splat schedule jitter into GPU buffers. A tilted helical delay field staggers per-splat departures; each Gaussian collapses to a velocity-stretched spark, rides an alternating-direction vortex with radial bulge and sine turbulence, and lands with a damped bounce, scale pop, and jitter-gated flash. Flight colors superheat the endpoint albedos of the two shapes only in transit, and every position, log-scale, quaternion, color, opacity, and SH coefficient settles into exact endpoints. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_splat Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/visual-effects. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats. ### Mesh to Splat Scene The complete Blender 4.0 splash courtyard by Gaku Tada becomes one explorable Gaussian scene through the Mesh to Splat CLI: 240 clean Eevee captures follow 80 anchors on the authored frame 0–80 camera path, with three translated views at every anchor. Adaptive densification and SH3 preserve the painted foliage, bicycle, architecture, and view-dependent detail before validated SOG compression makes the result browser-ready. A diagonal watercolor wash assembles the courtyard on entry, then a code-authored camera sequence plays through native orbit controls with a constrained 30-degree tilt. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_scene Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats. ### Mesh to Splat · Cave Lion A 535,086-splat SH3 reconstruction of a large female Panthera spelaea loads directly from the SOG produced by the Mesh to Splat Tools CLI. Native material opacity brings the lion into view over a warm radial cave-light backdrop, while orbit controls and an on-canvas CC-BY credit panel preserve an explorable presentation and complete source attribution. Canonical: https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_lion Renderer: webgpu; techniques: Splatting. Create paths: https://threejs-blocks.com/docs/create/product-visualization. Curated blocks: https://threejs-blocks.com/docs/blocks/gaussian-splats. ## Tutorials ### Your first Three Blocks scene: a product hero Build a compact product hero with convincing transmission, a controlled camera, complete lifecycle ownership, and a useful static fallback. Canonical: https://threejs-blocks.com/docs/tutorials/first-product-hero Difficulty: beginner; estimated time: 25 minutes; renderer: webgpu; verified: Three Blocks 0.4.0, Three.js 0.185.0. Chapters: Scaffold the scene; Shape the product hero; Own the lifecycle; Ship a useful fallback. ### Build a website with the starter Turn the generated Website template into a four-section story, keep scroll choreography in the worker-owned scene, and ship a fresh shader capture. Canonical: https://threejs-blocks.com/docs/tutorials/build-a-website-with-the-starter Difficulty: beginner; estimated time: 35 minutes; renderer: webgpu; verified: Three Blocks 0.4.0, Three.js 0.185.0. Chapters: Scaffold the Website template; Set one visual system; Choreograph four sections; Capture and deploy. ### Direct an interactive product cinematic Turn an approved camera render into a pointer-responsive presentation with bounded streaming, a controlled rest state, and poster fallback. Canonical: https://threejs-blocks.com/docs/tutorials/interactive-product-cinematic Difficulty: intermediate; estimated time: 50 minutes; renderer: webgpu; verified: Three Blocks 0.4.0, Three.js 0.185.0. Chapters: Load the authored shot; Map pointer intent; Direct the rest state; Bound streaming and cleanup. ### Art-direct a pointer-reactive atmospheric effect Build a stylized smoke volume, inject pointer motion as a force, and expose a measured quality ladder without obscuring simulation order. Canonical: https://threejs-blocks.com/docs/tutorials/stylized-pointer-vfx Difficulty: advanced; estimated time: 75 minutes; renderer: webgpu; verified: Three Blocks 0.4.0, Three.js 0.185.0. Chapters: Name the quality ladder; Initialize the volume; Inject pointer motion; Step before composite. ### Populate a large interactive world Sample a terrain on the GPU, cull invisible instances before shading, and keep interaction and readback costs bounded as the world grows. Canonical: https://threejs-blocks.com/docs/tutorials/large-interactive-world Difficulty: advanced; estimated time: 70 minutes; renderer: webgpu; verified: Three Blocks 0.4.0, Three.js 0.185.0. Chapters: Keep transforms on the GPU; Sample the world; Cull before shading; Bound interaction and readback. ## Concepts ### Precompiled shaders Choose and integrate precompiled shaders without leaving GPU work or browser fallbacks implicit. Rule: Treat precompiled shaders as a versioned optimization cache: live compilation keeps editing unblocked, and a strict build prevents stale receipts from shipping. Correct: Once shader-relevant imports settle, click Capture in the development overlay, use the CLI fallback when multiple routes changed, commit the saved shader and receipt together, then run the strict build and production preview. Incorrect: Recapture after every unrelated copy edit, or deploy a stale manifest while claiming the first frame is precompiled. Canonical: https://threejs-blocks.com/docs/concepts/precompiled-shaders ### Worker-owned rendering Choose and integrate worker-owned rendering without leaving GPU work or browser fallbacks implicit. Rule: Keep browser state on the page, GPU state in the worker, and every lifecycle or diagnostic message on the governed protocol. Correct: Use WorkerHost and createWorkerRuntime for the standard Three.js shell, or deliberately own canvas replacement and evidence when using the lower-level worker transport. Incorrect: Scatter postMessage calls across page and worker code, then rebuild restart, error, stats, and smoke behavior independently. Canonical: https://threejs-blocks.com/docs/concepts/worker-owned-rendering ### WebGPU renderer initialization Choose and integrate webgpu renderer initialization without leaving GPU work or browser fallbacks implicit. Rule: Await renderer initialization before any block allocates storage, compute pipelines, or render resources. Correct: Initialize once at the application boundary, then construct the scene and its blocks. Incorrect: Construct GPU systems during module evaluation and hope the first render initializes them in time. Canonical: https://threejs-blocks.com/docs/concepts/webgpu-initialization ### Compute before render Choose and integrate compute before render without leaving GPU work or browser fallbacks implicit. Rule: Schedule every producer before the render pass that consumes its storage for the current frame. Correct: Keep frame ordering visible in one coordinator or documented block lifecycle. Incorrect: Hide compute dispatches in unrelated effects that may run after render. Canonical: https://threejs-blocks.com/docs/concepts/compute-before-render ### Storage buffers and GPU ownership Choose and integrate storage buffers and gpu ownership without leaving GPU work or browser fallbacks implicit. Rule: Name the owner, writer, readers, lifetime, and disposal path for every shared GPU resource. Correct: Pass storage attributes directly from sampling to culling and rendering. Incorrect: Read transforms to JavaScript every frame and upload them again for the next block. Canonical: https://threejs-blocks.com/docs/concepts/gpu-ownership ### TSL composition Choose and integrate tsl composition without leaving GPU work or browser fallbacks implicit. Rule: State the node's input space, output type, and required stage before composing it. Correct: Compose small nodes at the material boundary and keep changing parameters in uniforms. Incorrect: Rebuild a node graph every frame or mix world, view, and screen coordinates implicitly. Canonical: https://threejs-blocks.com/docs/concepts/tsl-composition ### SDF versus BVH constraints Choose and integrate sdf versus bvh constraints without leaving GPU work or browser fallbacks implicit. Rule: Choose the representation from update frequency, required sign/precision, query count, and memory, not from naming. Correct: Use a stable SDF for many cheap field samples; keep BVH queries for geometry that needs direct surface precision. Incorrect: Rebuild a dense SDF every frame when a small number of BVH queries would answer the interaction. Canonical: https://threejs-blocks.com/docs/concepts/sdf-versus-bvh ### PBF versus SPH versus MPM Choose and integrate pbf versus sph versus mpm without leaving GPU work or browser fallbacks implicit. Rule: Choose from the required material response and quality ladder, then measure the full render path. Correct: Prototype the same interaction and particle count in the two plausible solvers before locking authoring work. Incorrect: Pick the solver with the most visually similar screenshot and inherit its tuning accidentally. Canonical: https://threejs-blocks.com/docs/concepts/simulation-choice ### Streaming versus preloading Choose and integrate streaming versus preloading without leaving GPU work or browser fallbacks implicit. Rule: Choose from asset size, first-use timing, seek pattern, memory ceiling, and fallback, not asset format alone. Correct: Preload a small hero loop; stream a long or view-dependent sequence with bounded buffers and a poster fallback. Incorrect: Stream every asset by default and discover decoder contention during the final page composition. Canonical: https://threejs-blocks.com/docs/concepts/streaming-versus-preloading ### Lifecycle and disposal Choose and integrate lifecycle and disposal without leaving GPU work or browser fallbacks implicit. Rule: Every complete integration states who starts, pauses, resizes, and disposes the block. Correct: Stop the animation loop and worker input before disposing shared GPU resources. Incorrect: Remove the canvas while timers, decoders, or storage buffers remain live. Canonical: https://threejs-blocks.com/docs/concepts/lifecycle-and-disposal ### Performance ladders and mobile fallbacks Choose and integrate performance ladders and mobile fallbacks without leaving GPU work or browser fallbacks implicit. Rule: Design the quality ladder with the block; do not bolt it on after the highest tier is approved. Correct: Scale resolution, passes, samples, counts, and DPR together around measured targets. Incorrect: Lower only particle count while an unchanged full-resolution compositing pass still dominates. Canonical: https://threejs-blocks.com/docs/concepts/performance-ladders ### MSDF versus runtime SDF text Choose and integrate msdf versus runtime sdf text without leaving GPU work or browser fallbacks implicit. Rule: Bake a known product charset; choose runtime generation only when user or remote content can introduce glyphs after deployment. Correct: Ship interface and campaign copy in a versioned MSDF atlas, then isolate genuinely dynamic text behind the runtime worker and cache boundary. Incorrect: Pay runtime glyph generation for a fixed headline, or omit required locales from a baked atlas and discover missing glyphs in production. Canonical: https://threejs-blocks.com/docs/concepts/msdf-versus-runtime-sdf-text ### Baked Motion versus VAV versus OAV Choose and integrate baked motion versus vav versus oav without leaving GPU work or browser fallbacks implicit. Rule: Choose the smallest representation that preserves the camera, lighting, geometry, material, and object-level controls the experience must still change. Correct: Use Baked Motion for a controlled hero view, VAV for a deforming surface that still needs live material or camera response, and OAV for many rigid transforms. Incorrect: Select by payload extension alone and discover after authoring that the runtime cannot relight, reframe, or address the required object. Canonical: https://threejs-blocks.com/docs/concepts/baked-motion-versus-vav-oav ### Splats versus live mesh versus render-baked presentation Choose and integrate splats versus live mesh versus render-baked presentation without leaving GPU work or browser fallbacks implicit. Rule: Rank required runtime freedoms first, then compare capture cleanup, payload, sorting/decoding, fallback, and target-device cost. Correct: Keep a production mesh for independent lighting and material changes, use splats for captured detail, or use Baked Motion when composition matters more than free camera motion. Incorrect: Choose the representation from one desktop screenshot without testing mobile memory, fallback behavior, or the final interaction envelope. Canonical: https://threejs-blocks.com/docs/concepts/splats-versus-live-mesh-versus-baked ### Hardware geometry versus sphere impostors Choose and integrate hardware geometry versus sphere impostors without leaving GPU work or browser fallbacks implicit. Rule: Measure both paths at the target particle size and overdraw; impostors win only when saved geometry exceeds their fragment and depth cost. Correct: Use geometry for large, close, low-count spheres and validate impostors in the final scene when their projected footprint remains bounded. Incorrect: Assume one triangle is always cheaper while large overlapping impostors saturate fragment shading and bandwidth. Canonical: https://threejs-blocks.com/docs/concepts/hardware-geometry-versus-sphere-impostors ## Authoring tool contracts ### Devtools Watch a Three Blocks app while you develop, and prepare shaders, text atlases, environment lighting, and GPU-compressed assets ahead of production. Canonical: https://threejs-blocks.com/docs/tools/devtools Delivery: cli; access: free; platforms: macOS, Windows, Linux, browser; verified against: @three-blocks/devtools 0.1.0. Install/activation: `npx three-blocks status`; `npx three-blocks shaders`; `npx three-blocks doctor`. - **Add the plugin and register the renderer:** Add threeBlocks() to a Vite app, then call registerDevtools({ renderer }) where the app creates its page-owned WebGPURenderer. - **Register shader keys:** Register each material, render pipeline, compute node, or shared-node container under a stable semantic key. - **Capture the current scene:** After shader inputs settle, click Capture in the development overlay. Use the driven CLI capture only for route batches and automated regeneration; the CLI capture also compresses public GLB and HDR assets to meshopt + KTX2. - **Optimize assets:** Compress any GLB, texture, or HDR environment to meshopt + KTX2 (BC6H-ready HDR) with exact download and VRAM accounting; the CLI capture keeps public GLB and HDR sources optimized automatically. Command: `npx three-blocks optimize`. - **Check freshness:** Verify every configured scene without launching a browser or GPU; stale state exits non-zero with the exact recovery command. Command: `npx three-blocks shaders`. - **Verify the release:** Prove zero registered live builds and pixel parity, then run the strict Vite build to reject stale artifacts. Command: `npx three-blocks shaders test`. Outputs: versioned WebGPU shader manifests, live-versus-precompiled parity evidence, development overlay, MSDF atlas, metrics, browser-font copy, and receipt, prefiltered environment KTX2, meshopt + KTX2 optimized GLB, texture, and HDR assets with a freshness receipt. - The runtime face is three-blocks/devtools plus the Vite plugin; the command face is npx three-blocks. - Devtools supports WebGPURenderer and rejects WebGLRenderer; rejected or stale shader entries compile live. - A current capture can report project-specific TSL build time saved; a shader-relevant edit makes that timing unavailable until the next capture. - On Three.js r185, every bundler adapter applies the same in-memory compatibility transform: #34068 captures node builders, #34069 stabilizes buffer labels, #34070 hydrates builder state, and the local compileAsync patch batches pipeline waits while balancing WebGPU error scopes. - The r185 transform never writes node_modules. Current captures require precompiled manifest version 3; recapture older artifacts instead of editing generated files. - The Vite plugin removes the devtools runtime from production bundles; production-aware bundlers select an import-free no-op, with the NODE_ENV guard as a condition-less fallback. - Text generation writes each configured browser-font copy, compressed .msdf.ktx2 atlas, .msdf.json metrics, and receipt under public/. - Environment bake writes a compressed, prefiltered KTX2 cube that loads without runtime PMREM generation. - Asset optimization rewrites GLB geometry with meshopt, encodes textures slot-aware to Basis Universal KTX2, converts HDR environments to UASTC HDR that transcodes to BC6H on capable GPUs, and records exact per-mip VRAM math in .three-blocks/assets/meta.json. Runtime consumers: https://threejs-blocks.com/docs/blocks/msdf-text. ### Three Blocks CLI Authenticate, diagnose a project, inspect available tools, and install supported authoring integrations. Canonical: https://threejs-blocks.com/docs/tools/three-blocks-cli Delivery: cli; access: free; platforms: macOS, Windows, Linux; verified against: Three Blocks Blender hub 0.3.3. Install/activation: `npm install three-blocks`; `npx three-blocks doctor`; `npx three-blocks install blender`. - **Install the public CLI:** The three-blocks package owns the CLI, so the project and its diagnostics use the same pinned version. Command: `npm install three-blocks`. - **Inspect the project:** Status and doctor report package, project, credential, Blender-hub, and optional splat-engine state before changing assets. Command: `npx three-blocks doctor`. - **Connect an authoring seat when needed:** Login uses the device or token flow; the free starter, status, shader, text, and Blender-hub commands do not become Pro runtime dependencies. Command: `npx three-blocks login`. - **Run or install the selected workflow:** List the entitled tool bundle or install the free Blender hub, then follow the canonical page for the generated artifact. Command: `npx three-blocks tools --help`. Outputs: project diagnostics, authoring-tool installations. - doctor is diagnostic: it reports project, credential, Blender hub, and splat-engine state without rewriting source assets. - install blender targets discovered Blender configuration directories; --zip writes an addon archive for manual installation. - Text commands generate an atlas and metadata consumed by the public MSDF runtime rather than browser-generated glyph geometry. Runtime consumers: none; this tool observes the application boundary directly. ### Baked Motion Video Convert Blender timeline, tilt-grid, or rotation renders into whole-file ActiveFrame packages. Canonical: https://threejs-blocks.com/docs/tools/baked-motion-video Delivery: cli-and-blender; access: pro-seat; platforms: macOS, Windows, Linux, Blender; verified against: Baked Motion Blender addon 1.5.1. Install/activation: `npx three-blocks login`; `npx three-blocks install blender`; `npx three-blocks doctor`; `npx three-blocks tools utsbv --help`. - **Author the camera array:** In Blender, choose a timeline, rotation, or two-axis tilt grid and lock camera, bounds, resolution, and frame order before rendering. - **Render synchronized channels:** The Blender addon writes the color frames and optional linear depth frames from the same camera samples. - **Encode the package:** The entitled UTSBV tool writes verified ActiveFrame resources for every motion mode: format 2 by default, or the format 3 paged atlas for tilt and rotation grids. Command: `npx three-blocks tools utsbv --help`. - **Load the browser runtime:** BakedMotion fetches each ActiveFrame resource once, admits its media, then exposes timeline, pointer, or view controls according to the authored mode. Outputs: .utsbv manifest, .af media tracks, depth and albedo data. - A format 2 .utsbv contains synchronized ActiveFrame media resources for timeline, tilt, and rotation modes. - A format 3 .utsbv packs neighbouring views into paged atlas frames and indexes every stream into hashed byte-range segments; it covers tilt and rotation grids only. - The manifest records mode, axes, frame order, camera, bounds, dimensions, hashes, and frame indexes. - The runtime validates whole-file resource hashes, dimensions, and ActiveFrame indexes before readiness. Runtime consumers: https://threejs-blocks.com/docs/blocks/baked-motion, https://threejs-blocks.com/docs/blocks/active-frame-video. ### Object Animation Video exporter Encode named rigid-object transforms into exact binary OAV packages. Canonical: https://threejs-blocks.com/docs/tools/object-animation-video Delivery: cli-and-blender; access: pro-seat; platforms: macOS, Windows, Linux, Blender; verified against: Object Animation Video Blender addon 1.0.1. Install/activation: `npx three-blocks login`; `npx three-blocks install blender`; `npx three-blocks doctor`; `npx three-blocks tools oav --help`. - **Select rigid objects:** Choose the Blender objects whose affine transforms need playback and preserve stable names and parent relationships. - **Bake object transforms:** The addon samples twelve affine components per object per frame in Three.js Y-up coordinates. - **Encode the OAV folder:** The entitled OAV tool quantizes twelve affine components once, writes one exact UTSBM track, verifies the post-quantization round trip, and commits the package atomically. Command: `npx three-blocks tools oav --help`. - **Bind runtime objects:** ObjectAnimationVideo loads manifest.json, binds by stable object name or index, and applies the decoded matrices during update. Outputs: OAV manifest, UTSBM transform track, machine-readable build report. - OAV schema 2 is the current public format and stores twelve 12-bit affine lanes in one exact UTSBM indexed-meshopt track. - The runtime reconstructs typed matrix arrays from the binary track; Three.js uploads changed object, instance, or batch matrix buffers to the GPU. - Every build report fingerprints the encoder and separates transfer, CPU memory, upload, and GPU residency instead of inferring decoder surfaces from package bytes. Runtime consumers: https://threejs-blocks.com/docs/blocks/object-animation-video. ### Vertex Animation Video exporter Encode deforming vertex positions, normals, and appearance into exact binary VAV packages. Canonical: https://threejs-blocks.com/docs/tools/vertex-animation-video Delivery: cli-and-blender; access: pro-seat; platforms: macOS, Windows, Linux, Blender; verified against: Vertex Animation Video Blender addon 1.4.1. Install/activation: `npx three-blocks login`; `npx three-blocks install blender`; `npx three-blocks doctor`; `npx three-blocks tools vav --help`. - **Prepare one deforming mesh:** Keep vertex topology and UV layout stable across the clip; record the intended frame range and frame rate. - **Bake Blender interchange:** The VAV addon samples positions, normals, and optional UV-space appearance into a .vavbake interchange file. - **Encode geometry and appearance:** The VAV encoder writes exact UTSBM numerical tracks. Optional UV-space visual appearance remains media; the distributed tools bundle owns the production encoder and its dependencies. Command: `npx three-blocks tools vav --help`. - **Load and update VAVMesh:** The browser runtime loads the manifest, allocates the vertex atlas, and advances geometry and appearance from the same clip time. Outputs: VAV manifest, UTSBM numerical tracks, optional UV visual media tracks, machine-readable build report. - The .vavbake interchange preserves stable topology, frame timing, quantization bounds, and optional UV-space appearance inputs. - VAV schema 2 is the current public format and stores geometry and per-vertex appearance in exact UTSBM indexed-meshopt tracks. - The runtime copies decoded atlas bytes into persistent R8 DataTextures; setting needsUpdate lets Three.js upload those arrays before the shader samples them. - UV-space appearance remains a visual media track, so its decoder census is separate from numerical geometry and per-vertex appearance. - Manifest timing, topology, quantization, and atlas dimensions are one runtime contract; regenerate related tracks together when any changes. Runtime consumers: https://threejs-blocks.com/docs/blocks/vertex-animation-video. ### Gaussian splat pipelines Capture a Blender still or timeline as a static Gaussian asset or validated 4DGS clip. Canonical: https://threejs-blocks.com/docs/tools/gaussian-splat-pipeline Delivery: cli-and-blender; access: pro-seat; platforms: macOS, Windows, Linux, Blender; verified against: Mesh to Splat Blender addon 0.2.6. Install/activation: `npx three-blocks login`; `npx three-blocks install splat-engine`; `npx three-blocks doctor`; `npx three-blocks tools splat --help`. - **Choose Still or Animation:** In Blender, Still captures the current frame. Animation uses the scene frame range, frame step, and frame rate. The CLI selects the same path with `--animation`. - **Install the native engine when needed:** The managed engine bundle contains the static Brush trainer and brush-spacetime. An older static-only cache updates automatically when an animation run starts. Command: `npx three-blocks install splat-engine`. - **Run the one-shot capture:** A still writes stable-ID PLY and SOG assets. Animation locks one camera rig over the full motion bounds, samples one barycentric identity table, trains every frame, and writes a gzip .b4dgs plus validation report. Command: `npx three-blocks tools splat --help`. - **Deliver the matching runtime asset:** GaussianSplats loads static PLY/SOG data. Convert the validated .b4dgs interchange to a SplatClip video tier before browser delivery when you need the animated runtime path. Outputs: .ply, .sids, .sog, .b4dgs, .b4dgs.json. - 4D capture requires stable object and mesh topology, but it does not reuse area-weighted indices independently per frame: one canonical triangle/barycentric plan follows the deforming surface. - Position, scale, opacity, rotation, and color are measured independently. Only attributes invariant within half a quantization step are stored once. - The encoder decodes the serialized container against every source PLY and deletes the candidate when any group exceeds its quantization bound. Runtime consumers: https://threejs-blocks.com/docs/blocks/gaussian-splats. ## Curated block contracts ### Transmission Render controllable refractive depth for glass and translucent product surfaces with an explicit quality cost. Canonical: https://threejs-blocks.com/docs/blocks/transmission Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: The product must keep live camera, light, roughness, thickness, or environment response while reading as refractive depth. Choose something else when: Use an opaque physical material when refraction is not visible, or Baked Motion when the approved pixels matter more than live relighting and free camera motion. Lifecycle: Create MeshTransmissionNodeMaterial only after the WebGPU renderer is initialized and the environment strategy is known. Update camera, object, and uniform values before render; do not rebuild the node material in the animation loop. Resize the renderer/camera normally and re-evaluate sample count or DPR when screen coverage changes materially. Dispose the material plus caller-owned geometry, environment textures, and render targets after stopping the loop. Performance: Screen coverage, transparent overlap, refraction samples, and back-side/depth work drive fragment cost. Environment resolution and any intermediate transmission targets set memory pressure. Use an opaque/low-sample fallback on constrained devices instead of hiding the product. ```ts import { MeshTransmissionNodeMaterial } from "three-blocks/transmission"; ``` Examples: https://threejs-blocks.com/examples/webgpu_material_transmission, https://threejs-blocks.com/examples/webgpu_baked_motion_rotation, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt. ### Baked Motion Turn a rendered camera or timeline sequence into an interactive, depth-aware browser presentation. Canonical: https://threejs-blocks.com/docs/blocks/baked-motion Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A controlled timeline, rotation, or tilt-grid interaction should preserve an approved rendered look without shipping the source scene. Choose something else when: Keep a live mesh for free camera/light/material changes; use VAV for deforming geometry or OAV for individually addressable rigid transforms. Lifecycle: Load one versioned .utsbv manifest after renderer initialization and retain the poster until ready and frameReady settle. Apply pointer/view/time input, call update(delta), then render the mesh that samples ActiveFrame slots. Resize camera/renderer; the authored camera and bounds stay fixed, so crop rather than extrapolate outside the captured range. Stop input and the animation loop before disposing BakedMotion, its ActiveFrame tracks, and the renderer. Performance: ActiveFrame wire bytes, decoded slots, dimensions, and frame-change rate dominate. Two-axis interpolation needs more resident slots than a timeline or one-axis rotation. Avoid texture-array preload beyond the configured memory cap. ```ts import { BakedMotion } from "three-blocks/baked-motion"; ``` Examples: https://threejs-blocks.com/examples/webgpu_baked_motion_timeline, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_baked_motion_rotation. ### Object Animation Video Replay compact authored transforms for many rigid parts while geometry, materials, lighting, and per-object binding remain live. Canonical: https://threejs-blocks.com/docs/blocks/object-animation-video Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser; availability: library; verified: 0.4.0. Use when: Many rigid objects need authored transform playback while geometry and materials remain live and separately addressable. Choose something else when: Use VAV for vertex deformation, Baked Motion for captured pixels, or ordinary AnimationMixer for small conventional clips. Lifecycle: Load the OAV manifest and exact UTSBM transform track, then bind by stable exported names or explicit indices. Advance update(delta) before rendering the bound Object3D or batched instances. Only the normal renderer/camera path resizes; the indexed transform track is immutable asset data. Unbind or restore targets, stop playback, dispose the exact-track reader, then release caller-owned scene objects. Performance: Object count, indexed-track fetch cadence, and matrix-application count scale the path. Batched targets avoid many scene-object updates when the mapping is stable. Keep one track owner per clip and stop it offscreen. ```ts import { ObjectAnimationVideo } from "three-blocks/experimental/object-animation-video"; ``` Examples: https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect. ### Vertex Animation Video Replay stable-topology mesh deformation and optional appearance while material, lighting, and camera response remain live. Canonical: https://threejs-blocks.com/docs/blocks/vertex-animation-video Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A deforming mesh must retain live camera/material response while its topology remains stable across an authored clip. Choose something else when: Use OAV for rigid transforms, Baked Motion for approved pixels, or skeletal/morph animation when its payload and deformation fit. Lifecycle: Load the VAV manifest, geometry base, exact UTSBM numerical tracks, and any selected UV visual tracks after renderer initialization. Advance mesh.update(delta) before render so geometry and appearance use the same clip time. Resize the renderer/camera only; atlas dimensions and encoded tracks are immutable asset facts. Stop playback, dispose VAVMesh and track streams, then release caller-owned lights/environment and renderer. Performance: Vertex count, atlas dimensions, numerical-track fetch bandwidth, optional visual-track decode, and interpolation scale cost. Appearance tracks can exceed geometry payload; omit them when live material is sufficient. Bound stream buffers and pause offscreen clips. ```ts import { VAVMesh } from "three-blocks/experimental/vertex-animation-video"; import { VAVTrackStream } from "three-blocks/experimental/vertex-animation-video"; ``` Examples: https://threejs-blocks.com/examples/webgpu_vav_basic. ### ActiveFrame Video Decode and synchronize compact GPU-ready animation frames with bounded browser-side resources. Canonical: https://threejs-blocks.com/docs/blocks/active-frame-video Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser, worker; availability: library; verified: 0.4.0. Use when: Code needs random or weighted access to GPU-ready frames rather than ordinary linear HTML video playback. Choose something else when: Use HTMLVideoElement for conventional playback or a higher-level Baked Motion/OAV/VAV block when a manifest already owns selection semantics. Lifecycle: Create AFVideo from one .af source after renderer initialization, await ready, and keep fallback media until firstFrame. Request only changed frame indices/weights before the material samples rgb/alpha nodes, then render. Track dimensions do not resize; update only the consuming geometry/camera and choose an asset tier intentionally. Stop frame requests, dispose AFVideo/decoder slots, then release consuming material and renderer. Performance: Track resolution, requested frames per interaction, slot count, and decode/upload cadence dominate. Weighted multi-frame sampling increases resident textures and fragment reads. Use lower-resolution tracks and fewer simultaneous slots on mobile. ```ts import { AFVideo } from "three-blocks/experimental/active-frame-video"; import { AFDecoder } from "three-blocks/experimental/active-frame-video"; ``` Examples: https://threejs-blocks.com/examples/webgpu_baked_motion_timeline, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_baked_motion_rotation. ### Gaussian Splats Render and stream captured 3D or animated Gaussian scenes with explicit sorting, memory, and quality controls. Canonical: https://threejs-blocks.com/docs/blocks/gaussian-splats Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser, worker; availability: library; verified: 0.4.0. Use when: Captured objects or spaces preserve view-dependent detail that would be expensive or slow to rebuild as a clean production mesh. Choose something else when: Use a live mesh for topology/material editing or Baked Motion for a tightly controlled approved camera envelope. Lifecycle: Load static, streaming, or animated manifest data after renderer initialization and keep the capture poster until ready. Update sorting/stream visibility for the current renderer and camera before render; advance animated clips on the same time owner. Resize renderer/camera and re-evaluate visible-density/quality tier; do not silently raise DPR with the same splat budget. Stop streams/clip playback, dispose splat objects and sort/compositor resources, then release renderer-owned targets. Performance: Visible splat count, sort/tile workload, overdraw, and SH degree drive GPU time. Compressed bytes, cell caches, decode staging, and upload peaks drive memory/network cost. Tier by visible density and capture resolution before removing fallback quality. ```ts import { GaussianSplats } from "three-blocks/gaussian-splats"; import { GaussianSplatsLoader } from "three-blocks/gaussian-splats"; import { GaussianSplatsStream } from "three-blocks/gaussian-splats"; ``` Examples: https://threejs-blocks.com/examples/webgpu_gaussiansplat_lit, https://threejs-blocks.com/examples/webgpu_gaussiansplat_4dgs_video, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_scene, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_lion, https://threejs-blocks.com/examples/webgpu_gaussiansplat_splat, https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer, https://threejs-blocks.com/examples/webgpu_points_bvh_volume. ### MSDF Text Draw crisp spatial or screen-space text from a pre-baked atlas with predictable runtime cost. Canonical: https://threejs-blocks.com/docs/blocks/msdf-text Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser; availability: library; verified: 0.4.0. Use when: The glyph set is known at build time and many crisp spatial or screen-space text items must batch predictably. Choose something else when: Use runtime SDF text for unknown user/remote glyphs or DOM text when selectable semantic copy does not need 3D placement. Lifecycle: Load one versioned atlas texture and parse its metrics, then construct MSDFText/BatchedMSDFText after renderer initialization. Change strings/layout only when content changes, call update, then render; move matrices/uniforms without rebuilding glyph geometry. Update viewport/screen offset for screen-space text and preserve readable CSS-equivalent size at each breakpoint. Dispose text batches and caller-owned atlas textures when the shared atlas owner is released. Performance: Glyph count, atlas size, layout churn, and batch fragmentation drive cost. One shared atlas and BatchedMSDFText reduce draw/material overhead. Cap atlas resolution and inactive capacities before compromising readability. ```ts import { MSDFText } from "three-blocks/msdf-text"; import { BatchedMSDFText } from "three-blocks/msdf-text"; ``` Examples: https://threejs-blocks.com/examples/webgl_text_input, https://threejs-blocks.com/examples/webgpu_text_msdf_batched, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. ### Runtime SDF Text Generate glyph distance fields at runtime when text cannot be known ahead of time, accepting its higher setup and memory cost. Canonical: https://threejs-blocks.com/docs/blocks/runtime-sdf-text Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser, worker; availability: library; verified: 0.4.0. Use when: Text or locales are genuinely unknown until runtime and the application can own asynchronous glyph generation and caching. Choose something else when: Use MSDF Text for a known production charset or DOM text for ordinary accessible interface copy. Lifecycle: Create Text, set font/content/layout, and await sync with the initialized renderer before revealing the result. Update transforms/uniforms normally; call sync only after content or layout properties change. Update max width/screen-space placement from layout breakpoints without regenerating unchanged glyphs. Dispose Text and stop any pending content owner before releasing renderer and shared font caches. Performance: First-use font fetch, glyph generation, atlas growth, and sync frequency dominate. Cache by font/style and avoid unique per-frame strings. Prewarm critical glyphs or choose MSDF for fixed headlines. ```ts import { Text } from "three-blocks/experimental/runtime-sdf-text"; import { BatchedText } from "three-blocks/experimental/runtime-sdf-text"; ``` Examples: https://threejs-blocks.com/examples/webgpu_text_sampler_skinned, https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. ### GPU Interaction Publish pointer, kinematic, and collider state once so multiple GPU systems can respond in the same frame. Canonical: https://threejs-blocks.com/docs/blocks/gpu-interaction Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Several GPU simulations or render systems need one normalized pointer/collider world, authority, metrics, and update order. Choose something else when: Keep input local when one small CPU-owned object needs it and no GPU system shares the state. Lifecycle: Create the system/world, register sources/simulations, then await initialize(renderer) after renderer.init(). Update source targets, await step(renderer, delta), then render every consumer of the shared storage. Update caller-owned coordinate mapping/camera; resize interaction buffers only when capacity/layout requirements change. Stop event producers, dispose/detach sources, then dispose the system after dependent simulations stop. Performance: Source/collider count, grid resolution, simulation bindings, and readback frequency scale cost. Share one world to avoid duplicate buffers and coordinate transforms. Request metrics readback slowly; never put it in the hot frame path. ```ts import { GPUInteractionSystem } from "three-blocks/experimental/gpu-interaction"; import { GPUInteractionWorld } from "three-blocks/experimental/gpu-interaction"; import { KinematicInteractionSource } from "three-blocks/experimental/gpu-interaction"; ``` Examples: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. ### Surface Sampling Populate static, skinned, or GPU-deformed surfaces without reading instance transforms back to the CPU. Canonical: https://threejs-blocks.com/docs/blocks/surface-sampling Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Large instance transforms must originate on a mesh surface and remain GPU-resident for later culling/rendering. Choose something else when: Sample on the CPU for small static populations or use authored transforms when exact placement matters more than distribution. Lifecycle: Create a static/dynamic/BVH sampler after renderer initialization with source geometry and target count. Recompute only when the source surface changes; pass output storage directly to culling/material consumers before render. No viewport resize is required; update only source transforms/bounds that change sampling space. Stop dependent consumers before disposing sampler/output storage and caller-owned source geometry. Performance: Source vertex/triangle count, target count, dynamic area rebuild, and dispatch count scale work. Readback destroys the intended GPU-resident path. Reuse output buffers and reduce resample frequency on mobile. ```ts import { ComputeMeshSurfaceSampler } from "three-blocks/surface-sampling"; import { ComputeMeshDynamicSurfaceSampler } from "three-blocks/surface-sampling"; import { ComputeBVHSampler } from "three-blocks/surface-sampling"; ``` Examples: https://threejs-blocks.com/examples/webgpu_text_sampler_skinned, https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### Instance Culling Cull large instance sets on the GPU before shading and drawing the visible survivors. Canonical: https://threejs-blocks.com/docs/blocks/instance-culling Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A GPU-resident instance population is much larger than the camera can show and survivors must feed indirect rendering. Choose something else when: Use ordinary frustum culling for small CPU-owned object sets or when per-instance bounds cannot be represented safely. Lifecycle: Attach mesh/geometry, reference transforms, bounds, and renderer after initialization; build storage before the first update. Set camera uniforms, run update, then render the material that resolves survivor indices and source transforms. Refresh camera projection/aspect and any orthographic scale; storage capacity changes require explicit reallocation. Stop consuming materials/batches, then dispose culling buffers, GUI/readback hooks, and caller-owned geometry. Performance: Instance count, bound tests, sort mode, and dispatch/synchronization count drive compute. Conservative bounds trade extra fragments for correctness. Avoid survivor readback in the render loop. ```ts import { ComputeInstanceCulling } from "three-blocks/instance-culling"; ``` Examples: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### Indirect Batching Merge heterogeneous meshes into a GPU-controlled batch and render the visible set with indirect draws. Canonical: https://threejs-blocks.com/docs/blocks/indirect-batching Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Many repeated or heterogeneous instances should share geometry/material storage and draw only GPU-selected survivors. Choose something else when: Use InstancedMesh for one small homogeneous set or individual objects when editability outweighs draw overhead. Lifecycle: Reserve honest vertex/index/instance capacities, add geometries and instances in a bulk update, then enable culling/indirect data. Update matrices/colors, run internal or external culling, then render the batch once. Refresh the camera used by culling; batch capacities do not grow implicitly with viewport changes. Stop culling producers, dispose the batch and its storage, then dispose caller-owned source geometry/materials once. Performance: Packed vertex/index bytes, instance count, culling mode, and mutation frequency are primary axes. Oversized reservations waste GPU memory; undersized ones force rebuilds. Avoid per-frame geometry/instance churn. ```ts import { IndirectBatchedMesh } from "three-blocks/indirect-batching"; ``` Examples: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh, https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect. ### Smoke Build pointer-reactive 2D or volumetric smoke with an explicit simulation and compositing quality ladder. Canonical: https://threejs-blocks.com/docs/blocks/smoke Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser; availability: library; verified: 0.4.0. Use when: Atmosphere must occupy a 3D volume, react to forces/objects, and composite with scene depth rather than behave as a flat overlay. Choose something else when: Use a TSL/post effect for screen-space atmosphere or particles when a volumetric pressure/density field is unnecessary. Lifecycle: Choose a quality tier, create/initialize SmokeVolume after renderer.init(), then configure render caches/material/compositor. Queue splats from input, step interaction then smoke compute, refresh caches as configured, and render/composite last. Scale renderer/compositor targets with viewport tier; simulation grid changes require explicit reallocation rather than every resize. Stop input/loop, dispose compositor/material, then smoke textures/compute resources and interaction world in owner order. Performance: 3D grid resolution, pressure iterations/solver, advection correction, turbulence, light steps, and compositor pixels multiply cost. Volume textures and multigrid intermediates set the memory floor. Reduce grid/cache resolution and update frequency together on mobile. ```ts import { SmokeVolume } from "three-blocks/smoke"; import { VolumeSmokeNodeMaterial } from "three-blocks/smoke"; import { smoke } from "three-blocks/smoke"; ``` Examples: https://threejs-blocks.com/examples/webgl_postprocessing_smoke, https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. ### Water Simulate and render interactive water from particle volume through surface or raymarched presentation. Canonical: https://threejs-blocks.com/docs/blocks/water Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A liquid needs particle/grid motion, a reconstructed surface, foam/whitewater, and live interaction rather than a shader-only plane. Choose something else when: Use OceanWaves/WaterNodeMaterial for a surface-only ocean or PBF/SPH when their particle behavior fits without MPM reconstruction. Lifecycle: Choose capacity/grid/domain/preset, construct WaterVolume after renderer.init(), then select surface or raymarch renderer/material. Apply interaction/forces, step WaterVolume before the surface renderer/material is consumed, then render. Resize camera/renderer and surface targets; keep grid/domain resolution fixed to an explicit quality tier. Stop the loop, dispose surface renderer/material, then water solver/fields/foam and renderer resources. Performance: Particle capacity, grid cells, solver passes, surface reconstruction, foam, and raymarch resolution dominate. Reduce particle, grid, reconstruction, foam, and raymarch work as one named quality tier. Validate the chosen quality tier on representative target devices with the final renderer size, DPR, population, interaction, and fallback enabled. ```ts import { WaterVolume } from "three-blocks/water"; import { WaterNodeMaterial } from "three-blocks/water"; import { WaterSurfaceRenderer } from "three-blocks/water"; import { WaterRayMarchRenderer } from "three-blocks/water"; ``` Examples: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean, https://threejs-blocks.com/examples/webgpu_simulation_water_compute. ### Material Point Method Build custom particle-grid simulations with explicit material models, forces, seeding, diagnostics, and render mirrors. Canonical: https://threejs-blocks.com/docs/blocks/mpm Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A particle-grid simulation needs a custom material response, force/collider hooks, diagnostics, or render mirror beyond the higher-level Water product. Choose something else when: Use Water for a production liquid surface, PBF for constraint-driven incompressibility, or SPH for direct pressure-force behavior. Lifecycle: Create MPMSolver with one material model and fixed capacity/grid options after renderer initialization, then seed its active particle prefix with a TSL initializer. Apply caller-owned inputs, call solver.step(renderer, delta) before any render mirror consumes particleBuffer, then render. Viewport changes affect only the caller-owned camera and render mirror; capacity, grid, and material layout changes require an explicit solver rebuild. Stop the frame loop and dependent render/readback work, dispose the solver, then release caller-owned geometry, materials, and renderer resources. Performance: Particle capacity, active count, grid-cell count, formulation, substeps, sorting, diagnostics, and render-mirror cost are the primary axes. Keep particle state GPU-resident and read diagnostics only at a bounded cadence. Reduce solver and render-mirror tiers together so a cheaper simulation does not retain an expensive presentation path. ```ts import { MPMSolver } from "three-blocks/mpm"; ``` Examples: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. ### Boids Simulate flocking in two or three dimensions with spatial-grid acceleration and optional volume constraints. Canonical: https://threejs-blocks.com/docs/blocks/boids Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Many agents need art-directed flocking, bounded motion, optional spatial acceleration, and GPU-resident transforms. Choose something else when: Use authored animation for predetermined paths or a particle solver when collision/material behavior matters more than steering. Lifecycle: Create Boids after renderer initialization with count/domain and optional grid/constraint/interaction policy. Update interaction, await boids.step(renderer, delta), then render the mesh/material consuming its instance matrix. Only camera/renderer resize; update domain dimensions when the world volume—not viewport—changes. Stop the loop, detach/dispose spatial grid and constraints/interaction owner, then release render resources. Performance: Agent count, neighbor-query path, grid rebuild, substeps, and render geometry scale cost. Enable the spatial grid only above the measured crossover. Use simple geometry/impostors for dense distant flocks. ```ts import { Boids } from "three-blocks/boids"; ``` Examples: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d. ### Position-Based Fluids Model interactive incompressible particles with iterative positional constraints and predictable iteration controls. Canonical: https://threejs-blocks.com/docs/blocks/pbf Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A particle fluid needs stable incompressibility and controllable constraints with a clear iteration-based quality ladder. Choose something else when: Choose SPH for force/pressure behavior or MPM/Water for grid-mediated material response and surface reconstruction. Lifecycle: Create PBF after renderer initialization with count/domain/material/neighbor policy and optional interaction/constraints. Update input/constraints, await step(renderer, delta), then render its GPU buffers through geometry or impostors. Resize only renderer/camera; change particle/domain capacity through an explicit rebuild/quality-tier transition. Stop loop, dispose render/culling material, then PBF/grid/constraints and renderer resources. Performance: Particle count, neighbor density, solver iterations, substeps, grid updates, and render path multiply cost. Reusing a spatial grid helps only after its build cost is amortized. Pair lower count/iterations with impostor and DPR tiers. ```ts import { PBF } from "three-blocks/pbf"; ``` Examples: https://threejs-blocks.com/examples/webgpu_material_transmission, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### Smoothed Particle Hydrodynamics Model pressure-driven particle fluids when force behavior matters more than PBF-style constraint convergence. Canonical: https://threejs-blocks.com/docs/blocks/sph Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A particle fluid needs explicit pressure/viscosity forces and force-driven material tuning rather than positional constraint correction. Choose something else when: Use PBF for constraint-stable incompressibility or MPM/Water for grid transfer and deformable/material behavior. Lifecycle: Create SPH after renderer initialization with domain/material/time-step and optional grid/interaction/constraint policy. Update forces/interaction, await step(renderer, delta), then render particle buffers. Resize only camera/renderer; rebuild capacity/domain only during a named tier change. Stop the loop, dispose render path, then SPH/grid/constraints and renderer. Performance: Particle count, neighbor queries, force passes, time-step substeps, and render path dominate. Grid acceleration has a count/distribution crossover that must be measured. Lower count and visual resolution together for mobile. ```ts import { SPH } from "three-blocks/sph"; ``` Examples: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### SDF and raymarching Build GPU-readable signed-distance fields for constraints, sampling, and raymarched surfaces or volumes — including live per-frame fields rebuilt from skinned characters. Canonical: https://threejs-blocks.com/docs/blocks/sdf-raymarching Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Many GPU queries need a stable signed field or a volume must be rendered/constrained from one sampled representation. Choose something else when: Use BVH queries for sparse precise surface work or live mesh rendering when a sampled field loses required thin detail. Lifecycle: Build/obtain a BVH, generate the SDF after renderer initialization, then pass the texture to raymarch material or constraints. Regenerate only when source geometry/bounds change; sample or raymarch the existing texture before render. Viewport resize affects raymarch screen cost, not field resolution; rebuild field only through an explicit quality/source change. Stop consumers, dispose material/constraints, then generator/3D texture and source geometry/BVH owner. Performance: Voxel count grows cubically with resolution; generation work follows geometry/BVH and grid size. Raymarch steps and screen coverage dominate rendering. Prefer stable fields and lower mobile resolution; avoid per-frame regeneration. ```ts import { ComputeSDFGenerator } from "three-blocks/sdf-raymarching"; import { RayMarchSDFNodeMaterial } from "three-blocks/sdf-raymarching"; import { BVHVolumeConstraint } from "three-blocks/sdf-raymarching"; import { SDFVolumeConstraint } from "three-blocks/sdf-raymarching"; import { SkinnedMeshSDF } from "three-blocks/sdf-raymarching"; ``` Examples: https://threejs-blocks.com/examples/webgpu_points_bvh_volume, https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### Sphere impostors Shade one-triangle particle impostors as lit spheres when hardware sphere geometry would dominate vertex cost. Canonical: https://threejs-blocks.com/docs/blocks/sphere-impostors Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: Dense spheres/particles are vertex-bound and their projected size/overdraw keeps analytic sphere shading cheaper than tessellated geometry. Choose something else when: Use hardware sphere geometry for close, large, low-count particles or when exact mesh silhouette/shadow behavior is required. Lifecycle: Create SphereImpostorNodeMaterial after renderer initialization and connect GPU position/radius nodes to triangle/instance geometry. Update particle storage/culling before render; keep sphere depth and lighting nodes stable. Resize renderer/camera and reconsider the tier when projected particle size or DPR changes. Stop simulation/culling, dispose impostor material/geometry, then release shared particle storage. Performance: Particle count, projected pixel area, overlap/overdraw, depth writes, and lighting dominate. Use hardware geometry when close or overlapping impostors become fragment-bound. Validate the chosen quality tier on representative target devices with the final renderer size, DPR, population, interaction, and fallback enabled. ```ts import { SphereImpostorNodeMaterial } from "three-blocks/sphere-impostors"; import { sphereImpostorPosition } from "three-blocks/sphere-impostors"; ``` Examples: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d, https://threejs-blocks.com/examples/webgpu_simulation_water_compute. ### Pristine grid Add an infinite anti-aliased reference grid with two independently styled world-space layers. Canonical: https://threejs-blocks.com/docs/blocks/grid-pristine Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser; availability: library; verified: 0.4.0. Use when: Editors, simulation previews, product staging, or technical scenes need a stable world-space scale reference. Choose something else when: Use authored floor geometry when the ground needs texture detail, collision, displacement, or an irregular boundary. Lifecycle: Create GridPristine with major and minor cell styles, then add it to the scene in the desired reference plane. Render normally; update only the public uniform values whose visual style changes. Resize the renderer and camera normally, then recheck line widths at the resulting DPR and camera distance. Remove the grid and call dispose() to release its geometry, material, and optional GUI folder. Performance: The grid is one analytical mesh with no texture payload. Fragment cost follows covered pixels and DPR. Reduce minor-layer opacity or hide the grid when it no longer communicates scale. ```ts import { GridPristine } from "three-blocks/grid-pristine"; ``` Examples: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### Core TSL effects Compose reusable film, painterly, Fresnel, parallax, projection, and noise treatments inside Three.js node materials and post passes. Canonical: https://threejs-blocks.com/docs/blocks/core-tsl-effects Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. Renderer: webgpu/webgl; environments: browser; availability: library; verified: 0.4.0. Use when: A reusable art-directed material/post effect can be expressed as typed node composition with explicit coordinate and render-stage inputs. Choose something else when: Use a volume/geometry block when the effect needs real spatial state, or a simple material property when a custom graph adds no visible value. Lifecycle: Compose the selected factory/node once after renderer setup and attach it to the documented material or post-processing slot. Update uniforms/nodes, not graph structure, before render or the owning post pass. Resize post targets and any screen-space texel inputs; material-space nodes need no viewport rebuild. Stop post loop, dispose post targets/materials/textures, then renderer resources. Performance: Screen coverage, texture reads, samples/kernel radius, branches, and overlapping post passes drive cost. Graph rebuilds trigger shader compilation; uniforms do not. Disable or simplify expensive passes for reduced/mobile tiers. ```ts import { filmHD } from "three-blocks/core-tsl-effects"; import { kuwahara } from "three-blocks/core-tsl-effects"; import { fresnel } from "three-blocks/core-tsl-effects"; import { parallaxOcclusion } from "three-blocks/core-tsl-effects"; import { biplanarTexture } from "three-blocks/core-tsl-effects"; ``` Examples: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. ### Compute foundations Use sorting, prefix sums, batching, and GPU-generated geometry as the data-moving foundation for larger blocks. Canonical: https://threejs-blocks.com/docs/blocks/compute-foundations Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. Renderer: webgpu; environments: browser; availability: library; verified: 0.4.0. Use when: A higher-level block needs deterministic GPU prefix sums, sorting, batching, readback, or resource-disposal primitives. Choose something else when: Stay on a curated product block when it already owns these passes; do not assemble low-level compute solely to avoid its lifecycle contract. Lifecycle: Allocate typed storage after renderer initialization, create the primitive with fixed capacity/options, and validate device limits. Write producers, run prefix/sort/batch compute in dependency order, then let culling/render consumers read the result. Viewport changes do not resize compute buffers; capacity/type changes require an explicit rebuild. Stop consumers/readbacks, dispose compute primitives and owned storage, then renderer. Performance: Element count, pass count, workgroup shape, synchronization, and readback frequency dominate. Keep diagnostic readback asynchronous and outside the frame loop. Validate the chosen quality tier on representative target devices with the final renderer size, DPR, population, interaction, and fallback enabled. ```ts import { ComputeRadixSort } from "three-blocks/experimental/compute-foundations"; import { ComputePrefixSum } from "three-blocks/experimental/compute-foundations"; import { ComputeBitonicSort } from "three-blocks/experimental/compute-foundations"; ``` Examples: none. ## Exhaustive public API ### ACTIVE_FRAME_TYPE Kind: variable; canonical: https://threejs-blocks.com/docs/api/ACTIVE_FRAME_TYPE. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ACTIVE_FRAME_TYPE } from "three-blocks/experimental/active-frame-video"; const ACTIVE_FRAME_TYPE: "active-frame" ``` **Purpose:** Persisted discriminator for the normalized ActiveFrame runtime manifest. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ACTIVE_FRAME_TYPE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### ACTIVE_FRAME_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/ACTIVE_FRAME_VERSION. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ACTIVE_FRAME_VERSION } from "three-blocks/experimental/active-frame-video"; const ACTIVE_FRAME_VERSION: 1 ``` **Purpose:** ActiveFrame runtime manifest version understood by this release. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ACTIVE_FRAME_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFDecoder Kind: variable; canonical: https://threejs-blocks.com/docs/api/AFDecoder. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { AFDecoder } from "three-blocks/experimental/active-frame-video"; const AFDecoder: AFDecoderConstructor ``` **Purpose:** Frame-accurate runtime decoder for one ActiveFrame clip. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. - `readonly busy: boolean`: Whether encoded chunks remain queued on the underlying codec. - `new (source: AFDecoderSource, options?: AFDecoderOptions): AFDecoder` - `dispose(): void`: Close the owned decoder and stop delivery. Idempotent; frames already delivered to the process callback remain callback-owned and must still be closed there. - `readonly frame: number | null`: Last frame index handed to the decoder output callback. - `readonly frameProcessed: number | null`: Last requested frame index whose process callback completed. - `readonly loading: Promise`: Resolves after manifest parsing and decoder configuration. Rejects on fetch, container, codec-support, or WebCodecs initialization failure. - `readonly manifest: ActiveFrameManifest | null`: Parsed manifest after AFDecoder.loading resolves; cleared by disposal. - `readonly pending: boolean`: Whether requested frames have not yet reached the process callback. - `request(frames: Iterable): void`: Request a set of frame indices, decoding each required GOP at most once. - `setFrame(index: number): void`: Request one clamped integer frame. ### AFDecoderErrorCallback Kind: type; canonical: https://threejs-blocks.com/docs/api/AFDecoderErrorCallback. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFDecoderErrorCallback } from "three-blocks/experimental/active-frame-video"; type AFDecoderErrorCallback = (error: unknown) => void ``` **Purpose:** Fatal initialization or WebCodecs failure callback. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFDecoderErrorCallback. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFDecoderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AFDecoderOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFDecoderOptions } from "three-blocks/experimental/active-frame-video"; interface AFDecoderOptions ``` **Purpose:** Runtime options for AFDecoder. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFDecoderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. - `colorSpace?: VideoColorSpaceInit | null`: Optional WebCodecs colour-space override for decoded samples. - `firstDecodeTimeout?: number`: Wall-clock milliseconds allowed for the first requested keyframe output. - `hardwareAcceleration?: HardwareAcceleration`: WebCodecs hardware-acceleration preference. - `onError?: AFDecoderErrorCallback`: Notification for initialization or codec failure. - `process?: AFDecoderProcess`: Owned-frame sink; the default closes each delivered frame immediately. ### AFDecoderProcess Kind: type; canonical: https://threejs-blocks.com/docs/api/AFDecoderProcess. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFDecoderProcess } from "three-blocks/experimental/active-frame-video"; type AFDecoderProcess = (frame: VideoFrame, id: number) => void | Promise ``` **Purpose:** Sink for requested decoded frames. The callback takes ownership of every delivered frame and must close it after its final GPU/CPU use. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFDecoderProcess. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFDecoderSource Kind: type; canonical: https://threejs-blocks.com/docs/api/AFDecoderSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFDecoderSource } from "three-blocks/experimental/active-frame-video"; type AFDecoderSource = string | ArrayBuffer | {manifest: ActiveFrameManifest;} | ActiveFrameEncodedSource ``` **Purpose:** URL, encoded bytes, a fully parsed manifest, or an indexed source accepted by AFDecoder. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFDecoderSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideo Kind: variable; canonical: https://threejs-blocks.com/docs/api/AFVideo. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { AFVideo } from "three-blocks/experimental/active-frame-video"; const AFVideo: AFVideoConstructor ``` **Purpose:** GPU-resident runtime playback and sampling facade for one ActiveFrame clip. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. - `readonly a: AFVideoScalarNode | null`: Interpolated alpha node, or `null` before the sampling graph exists. - `readonly alphaNode: AFVideoScalarNode | null`: Named compatibility output for assigning directly to a material opacity node. - `new (source: AFVideoSource, options?: AFVideoOptions): AFVideo` - `dispose(): void`: Close owned decoders and frames and dispose owned textures. Idempotent; pending frame readiness resolves with `null`, and consuming materials remain caller-owned. - `readonly firstFrame: Promise`: Resolves after the first frame reaches a texture, or with `null` after early suspension/disposal. - `readonly hasAlpha: boolean`: Whether the container includes a separately decoded alpha track. - `readonly manifest: ActiveFrameManifest | null`: Parsed container manifest after AFVideo.ready resolves. - `readonly node: AFVideoNode | null`: Interpolated RGBA node sampled at the material's current UV. - `readonly ready: Promise`: Resolves after manifest parsing and decoder configuration. Rejects on fetch, container, codec-support, or WebCodecs initialization failure. - `resume(): Promise`: Recreate parked decoders against the retained source without replacing texture identities. - `readonly rgb: AFVideoRGBNode`: Interpolated RGB node. - `sample(uvNode: AFVideoUVNode): AFVideoNode`: Sample the current interpolated frame set at a custom UV node. - `sampleSlot(slot: number, uvNode: AFVideoUVNode): AFVideoNode`: Sample one physical slot without applying temporal interpolation. - `sampleWeighted(uvNode: AFVideoUVNode): AFVideoNode`: Sample all assigned bounded slots using the weights from the latest `setFrames()` call. - `setFrame(frame: number): Promise`: Request a fractional frame and resolve after its visible bracket reaches the textures. - `setFrames(indices: readonly number[], weights?: readonly number[], options?: AFVideoSetFramesOptions): Promise`: Request an arbitrary weighted frame set within the fixed slot budget. - `readonly slotCount: number`: Fixed number of decoded texture slots allocated by this instance. - `suspend(): void`: Park decoders and release their admission leases while retaining the displayed textures. - `readonly totalFrames: number`: Number of frames in the primary media track. ### AFVideoFrameResult Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoFrameResult. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoFrameResult } from "three-blocks/experimental/active-frame-video"; type AFVideoFrameResult = AFVideo | null ``` **Purpose:** A completed frame request, or `null` when a newer request superseded it. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoFrameResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideoNode Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoNode. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoNode } from "three-blocks/experimental/active-frame-video"; type AFVideoNode = THREE.Node<'vec4'> ``` **Purpose:** Interpolated RGBA output returned by ActiveFrame sampling methods. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideoOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AFVideoOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoOptions } from "three-blocks/experimental/active-frame-video"; interface AFVideoOptions ``` **Purpose:** Runtime texture and decoder options for AFVideo. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. - `colorSpace?: THREE.ColorSpace`: Three.js colour space assigned to visual texture slots. - `cpuUpload?: boolean`: Copy decoded RGBA frames into stable data-texture slots. - `dataChannel?: boolean`: Copy luma into data textures instead of sampling colour-managed video textures. - `decoderColorSpace?: VideoColorSpaceInit | null`: Optional WebCodecs colour-space override. - `encodedStream?: 'color' | 'depth'`: Primary stream selected when the source is indexed. - `firstDecodeTimeout?: number`: Wall-clock deadline for each decoder's first requested keyframe output. - `flipY?: boolean`: Whether decoded frames are flipped vertically for conventional UVs. - `hardwareAcceleration?: HardwareAcceleration`: WebCodecs hardware-acceleration preference. - `magFilter?: THREE.MagnificationTextureFilter`: Texture magnification filter. - `minFilter?: THREE.MinificationTextureFilter`: Texture minification filter. - `slots?: number`: Fixed decoded-frame slot budget; two supports ordinary fractional playback. ### AFVideoRGBNode Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoRGBNode. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoRGBNode } from "three-blocks/experimental/active-frame-video"; type AFVideoRGBNode = THREE.Node<'vec3'> ``` **Purpose:** Interpolated RGB output node exposed by an ActiveFrame clip. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoRGBNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideoScalarNode Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoScalarNode. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoScalarNode } from "three-blocks/experimental/active-frame-video"; type AFVideoScalarNode = THREE.Node<'float'> ``` **Purpose:** Interpolated scalar output node used for alpha and individual data channels. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoScalarNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideoSetFramesOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AFVideoSetFramesOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoSetFramesOptions } from "three-blocks/experimental/active-frame-video"; interface AFVideoSetFramesOptions ``` **Purpose:** Controls whether a bounded frame-set request waits for all requested slots. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoSetFramesOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. - `wait?: boolean`: Await texture readiness; set `false` for fire-and-forget interaction updates. ### AFVideoSource Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoSource } from "three-blocks/experimental/active-frame-video"; type AFVideoSource = AFDecoderSource ``` **Purpose:** Input accepted by AFVideo. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AFVideoUVNode Kind: type; canonical: https://threejs-blocks.com/docs/api/AFVideoUVNode. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { AFVideoUVNode } from "three-blocks/experimental/active-frame-video"; type AFVideoUVNode = THREE.Node<'vec2'> ``` **Purpose:** UV input node accepted by custom ActiveFrame sampling methods. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AFVideoUVNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AbortSignalLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/AbortSignalLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AbortSignalLike } from "three-blocks/assets"; interface AbortSignalLike ``` **Purpose:** Declares AbortSignalLike as a public interface. It is exported from three-blocks/assets. Its declared surface covers aborted, addEventListener, reason, and removeEventListener. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AbortSignalLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly aborted: boolean` - `addEventListener(type: 'abort', listener: () => void, options?: {readonly once?: boolean;}): void` - `readonly reason?: unknown` - `removeEventListener(type: 'abort', listener: () => void): void` ### ActiveFrameEncodedSource Kind: type; canonical: https://threejs-blocks.com/docs/api/ActiveFrameEncodedSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ActiveFrameEncodedSource } from "three-blocks/experimental/active-frame-video"; type ActiveFrameEncodedSource = AFEncodedSourceImplementation ``` **Purpose:** Demand-filled encoded source shared by indexed color/depth and optional alpha decoders. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ActiveFrameEncodedSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### ActiveFrameFrame Kind: type; canonical: https://threejs-blocks.com/docs/api/ActiveFrameFrame. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ActiveFrameFrame } from "three-blocks/experimental/active-frame-video"; type ActiveFrameFrame = AFFrameImplementation ``` **Purpose:** One encoded frame descriptor and its zero-copy byte view in an ActiveFrame container. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ActiveFrameFrame. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### ActiveFrameManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/ActiveFrameManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ActiveFrameManifest } from "three-blocks/experimental/active-frame-video"; type ActiveFrameManifest = Readonly ``` **Purpose:** Parsed, validated ActiveFrame v1 container manifest, including an optional alpha track. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ActiveFrameManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### ActiveFrameTrackManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/ActiveFrameTrackManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ActiveFrameTrackManifest } from "three-blocks/experimental/active-frame-video"; type ActiveFrameTrackManifest = AFTrackManifestImplementation ``` **Purpose:** Codec, dimensions, timing, and frame index for one ActiveFrame media track. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ActiveFrameTrackManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### AppChannel Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppChannel. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppChannel } from "three-blocks/app"; interface AppChannel ``` **Purpose:** Declares AppChannel as a public interface. It is exported from three-blocks/app. Its declared surface covers events, requests, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppChannel. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly events: TEvents` - `readonly requests: TRequests` - `readonly state: TState` ### AppHotContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppHotContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppHotContext } from "three-blocks/app"; interface AppHotContext ``` **Purpose:** Declares AppHotContext as a public interface. It is exported from three-blocks/app. Its declared surface covers dispose and on. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(callback: () => void): void` - `on(event: 'three-blocks:worker-restart', callback: (payload: {readonly path: string;}) => void): void` ### AppPageEvents Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppPageEvents. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppPageEvents } from "three-blocks/app"; interface AppPageEvents ``` **Purpose:** Declares AppPageEvents as a public interface. It is exported from three-blocks/app. Its declared surface covers error, textReplay, and texture. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppPageEvents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly error: SerializedWorkerError` - `readonly textReplay: {readonly reason: string;}` - `readonly texture: StatsTextureFrame` ### AppPageRequests Kind: type; canonical: https://threejs-blocks.com/docs/api/AppPageRequests. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppPageRequests } from "three-blocks/app"; type AppPageRequests = Record ``` **Purpose:** Declares AppPageRequests as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppPageRequests. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AppPageState Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppPageState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppPageState } from "three-blocks/app"; interface AppPageState ``` **Purpose:** Declares AppPageState as a public interface. It is exported from three-blocks/app. Its declared surface covers diagnostics, lifecycle, stats, textError, and textFallback, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppPageState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly diagnostics: RuntimeDiagnostics` - `readonly lifecycle: RuntimeStatus` - `readonly stats: StatsSnapshot` - `readonly textError: TextErrorState` - `readonly textFallback: TextFallbackSignal` - `readonly textReady: TextReadyState` - `readonly tsl: ThreeBlocksTslBuildSnapshot` ### AppProtocol Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppProtocol. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppProtocol } from "three-blocks/app"; interface AppProtocol ``` **Purpose:** Declares AppProtocol as a public interface. It is exported from three-blocks/app. Its declared surface covers page and worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppProtocol. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly page: AppChannel` - `readonly worker: AppChannel` ### AppScene Kind: type; canonical: https://threejs-blocks.com/docs/api/AppScene. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppScene } from "three-blocks/app"; type AppScene = Object3D & HotScene & {update(delta: number, scroll: ScrollState): void; pointer?(pointer: PointerState): void;} ``` **Purpose:** Declares AppScene as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: update. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AppStatsControl Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppStatsControl. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsControl } from "three-blocks/app"; interface AppStatsControl ``` **Purpose:** Serializable page-to-worker state for an on-demand stats profiler. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsControl. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly active: boolean` - `readonly mode: AppStatsPanelMode` - `readonly visible: boolean` ### AppStatsController Kind: class; canonical: https://threejs-blocks.com/docs/api/AppStatsController. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AppStatsController } from "three-blocks/app"; class AppStatsController ``` **Purpose:** Main-thread owner for lazy stats panels, smoke counters, and an optional worker handshake. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `attach(stats: StatsMainAdapter): void`: Attach and initialize a caller-owned adapter. Replaced adapters are disposed. - `constructor(options: AppStatsControllerOptions)` - `dispose(): void` - `receive(snapshot: StatsSnapshot): void`: Receive one worker metrics sample and advance the smoke counter. - `receiveTexture(frame: StatsTextureFrame): void`: Receive one transferred texture and advance the smoke counter. - `replay(): Promise`: Reapply the active page state after its render worker is replaced. - `setPanelMode(mode: AppStatsPanelMode): Promise` - `setPanelVisible(visible: boolean): Promise` - `readonly state: AppStatsState` ### AppStatsControllerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppStatsControllerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsControllerOptions } from "three-blocks/app"; interface AppStatsControllerOptions ``` **Purpose:** Declares AppStatsControllerOptions as a public interface. It is exported from three-blocks/app. Its declared surface covers container, control, createAdapter, onError, and stats, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsControllerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly container?: HTMLElement` - `readonly control?: (value: AppStatsControl) => PromiseLike`: Optional worker handshake. Its presence enables worker-owned compatibility semantics. - `readonly createAdapter?: (options: StatsMainOptions) => StatsMainAdapter`: Test or host-specific adapter factory. - `readonly onError?: (error: unknown) => void` - `readonly stats?: StatsMainAdapter`: Attach an existing adapter instead of creating one on first visible demand. - `readonly textureSource: () => object | null | undefined`: Resolve the currently presented canvas. The result may change after a worker restart. ### AppStatsFrameHooks Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppStatsFrameHooks. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsFrameHooks } from "three-blocks/app"; interface AppStatsFrameHooks ``` **Purpose:** Declares AppStatsFrameHooks as a public interface. It is exported from three-blocks/app. Its declared surface covers beginFrame and endFrame. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsFrameHooks. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `beginFrame(): void` - `endFrame(): void` ### AppStatsPanelMode Kind: type; canonical: https://threejs-blocks.com/docs/api/AppStatsPanelMode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsPanelMode } from "three-blocks/app"; type AppStatsPanelMode = Exclude ``` **Purpose:** Declares AppStatsPanelMode as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsPanelMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AppStatsState Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppStatsState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsState } from "three-blocks/app"; interface AppStatsState ``` **Purpose:** Stable stats portion of the browser smoke bridge. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly panelVisible: boolean`: Requested visibility. A hidden document temporarily suppresses the DOM panel. - `setPanelMode(mode: AppStatsPanelMode): Promise` - `setPanelVisible(visible: boolean): Promise` - `readonly snapshots: number` - `readonly textures: number` ### AppStatsWorkerController Kind: class; canonical: https://threejs-blocks.com/docs/api/AppStatsWorkerController. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AppStatsWorkerController } from "three-blocks/app"; class AppStatsWorkerController implements AppStatsFrameHooks ``` **Purpose:** Worker-side on-demand profiler paired with AppStatsController's control callback. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `applyControl(control: AppStatsControl): Promise` - `beginFrame(): void` - `constructor(options: AppStatsWorkerControllerOptions)` - `dispose(): void` - `endFrame(): void` ### AppStatsWorkerControllerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppStatsWorkerControllerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppStatsWorkerControllerOptions } from "three-blocks/app"; interface AppStatsWorkerControllerOptions ``` **Purpose:** Declares AppStatsWorkerControllerOptions as a public interface. It is exported from three-blocks/app. Its declared surface covers createAdapter, onActive, publish, renderer, and stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppStatsWorkerControllerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly createAdapter?: (options: StatsWorkerOptions) => StatsWorkerAdapter` - `readonly onActive?: (hooks: AppStatsFrameHooks) => void | (() => void)`: Attach frame hooks after lazy initialization. Return cleanup for disposal. - `readonly publish: (snapshot: StatsSnapshot) => void` - `readonly renderer: object` - `readonly stats?: StatsWorkerAdapter` ### AppWorkerEvents Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppWorkerEvents. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppWorkerEvents } from "three-blocks/app"; interface AppWorkerEvents ``` **Purpose:** Declares AppWorkerEvents as a public interface. It is exported from three-blocks/app. Its declared surface covers refresh and textBatch. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppWorkerEvents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly refresh: {readonly reason: string;}` - `readonly textBatch: TextSyncDelivery` ### AppWorkerRequests Kind: type; canonical: https://threejs-blocks.com/docs/api/AppWorkerRequests. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppWorkerRequests } from "three-blocks/app"; type AppWorkerRequests = Record ``` **Purpose:** Declares AppWorkerRequests as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppWorkerRequests. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AppWorkerState Kind: interface; canonical: https://threejs-blocks.com/docs/api/AppWorkerState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AppWorkerState } from "three-blocks/app"; interface AppWorkerState ``` **Purpose:** Declares AppWorkerState as a public interface. It is exported from three-blocks/app. Its declared surface covers boot, pointer, scroll, statsPanel, and viewport, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AppWorkerState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly boot: WorkerBootState` - `readonly pointer: PointerState` - `readonly scroll: ScrollState` - `readonly statsPanel: StatsTexturePanelState & {readonly name: string;}` - `readonly viewport: ViewportState` - `readonly visibility: VisibilityState` ### AssetAdapter Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetAdapter. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetAdapter } from "three-blocks/assets"; interface AssetAdapter ``` **Purpose:** Declares AssetAdapter as a public interface. It is exported from three-blocks/assets. Its declared surface covers capabilities, dispose, load, and type. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: load and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly capabilities?: AssetAdapterCapabilities` - `dispose?(value: TResult, context: AssetDisposeContext): void | PromiseLike` - `load(definition: TDefinition, context: AssetLoadContext): TResult | PromiseLike` - `readonly type: TDefinition['type']` ### AssetAdapterCapabilities Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetAdapterCapabilities. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetAdapterCapabilities } from "three-blocks/assets"; interface AssetAdapterCapabilities ``` **Purpose:** Declares AssetAdapterCapabilities as a public interface. It is exported from three-blocks/assets. Its declared surface covers codecs, formats, notes, and workerSafe. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetAdapterCapabilities. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly codecs?: {readonly draco?: boolean; readonly ktx2?: boolean; readonly meshopt?: boolean; readonly gltfCurve?: boolean;}` - `readonly formats?: readonly string[]` - `readonly notes?: string` - `readonly workerSafe?: boolean` ### AssetAdapterDefinition Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetAdapterDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetAdapterDefinition } from "three-blocks/assets"; type AssetAdapterDefinition = TAdapter extends AssetAdapter ? TDefinition: never ``` **Purpose:** Declares AssetAdapterDefinition as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetAdapterDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetAdapterRecord Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetAdapterRecord. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetAdapterRecord } from "three-blocks/assets"; type AssetAdapterRecord = Readonly>> ``` **Purpose:** Declares AssetAdapterRecord as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetAdapterRecord. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetAdapterResult Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetAdapterResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetAdapterResult } from "three-blocks/assets"; type AssetAdapterResult = TAdapter extends AssetAdapter ? TResult: never ``` **Purpose:** Declares AssetAdapterResult as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetAdapterResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetAggregateError Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetAggregateError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetAggregateError } from "three-blocks/assets"; class AssetAggregateError extends Error ``` **Purpose:** Declares AssetAggregateError as a public class. It is exported from three-blocks/assets. Its declared surface covers failures and optionalFailures, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(failures: readonly AssetFailure[], optionalFailures?: readonly AssetFailure[])` - `readonly failures: readonly AssetFailure[]` - `readonly optionalFailures: readonly AssetFailure[]` ### AssetCacheEntrySnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetCacheEntrySnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetCacheEntrySnapshot } from "three-blocks/assets"; interface AssetCacheEntrySnapshot ``` **Purpose:** Declares AssetCacheEntrySnapshot as a public interface. It is exported from three-blocks/assets. Its declared surface covers key, persistent, progress, references, and status, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetCacheEntrySnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly key: string` - `readonly persistent: boolean` - `readonly progress: number` - `readonly references: number` - `readonly status: 'queued' | 'loading' | 'ready'` - `readonly type: string` ### AssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetDefinition } from "three-blocks/assets"; interface AssetDefinition ``` **Purpose:** Declares AssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers bytes, cacheKey, metadata, persistent, and required, plus 4 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bytes?: number` - `readonly cacheKey?: string` - `readonly metadata?: Readonly>` - `readonly persistent?: boolean` - `readonly required?: boolean` - `readonly retry?: AssetRetry` - `readonly type: TType` - `readonly url?: TUrl` - `readonly variants?: AssetVariants` ### AssetDefinitionForAdapters Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetDefinitionForAdapters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetDefinitionForAdapters } from "three-blocks/assets"; type AssetDefinitionForAdapters = {[TKey in keyof TAdapters]: AssetAdapterDefinition;}[keyof TAdapters] ``` **Purpose:** Declares AssetDefinitionForAdapters as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetDefinitionForAdapters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetDevice Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetDevice. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetDevice } from "three-blocks/assets"; type AssetDevice = 'desktop' | 'mobile' ``` **Purpose:** Shared, renderer-agnostic asset contracts. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetDevice. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetDisposeContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetDisposeContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetDisposeContext } from "three-blocks/assets"; interface AssetDisposeContext ``` **Purpose:** Declares AssetDisposeContext as a public interface. It is exported from three-blocks/assets. Its declared surface covers reason. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetDisposeContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly reason: 'zero-references' | 'evicted' | 'shutdown'` ### AssetFailure Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetFailure. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetFailure } from "three-blocks/assets"; interface AssetFailure ``` **Purpose:** Declares AssetFailure as a public interface. It is exported from three-blocks/assets. Its declared surface covers assetName, assetType, error, and required. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetFailure. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assetName: string` - `readonly assetType: string` - `readonly error: AssetLoadError` - `readonly required: boolean` ### AssetHandle Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetHandle. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetHandle } from "three-blocks/assets"; class AssetHandle ``` **Purpose:** Declares AssetHandle as a public class. It is exported from three-blocks/assets. Its declared surface covers name, promise, release, and released, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and release. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(name: string, promise: Promise, release: () => void)` - `readonly name: string` - `readonly promise: Promise` - `release(): void` - `get released(): boolean` ### AssetLease Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetLease. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetLease } from "three-blocks/assets"; class AssetLease ``` **Purpose:** A direct-await ownership object that keeps the underlying reference handles reachable. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and release. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assets: TResult` - `constructor(assets: TResult, request: AssetLoad)` - `release(): void` - `get released(): boolean` - `readonly request: AssetLoad` ### AssetLoad Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetLoad. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetLoad } from "three-blocks/assets"; class AssetLoad implements PromiseLike ``` **Purpose:** Declares AssetLoad as a public class. It is exported from three-blocks/assets. Its declared surface covers handles, named, optionalFailures, progress, and release, plus 4 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and release. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(records: readonly InternalLoadRecord[], progress: ProgressTracker)` - `readonly handles: NamedAssetHandles` - `readonly named: NamedAssetPromises` - `get optionalFailures(): readonly AssetFailure[]` - `get progress(): number` - `release(): void` - `get released(): boolean` - `readonly result: Promise` - `then(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike) | null): PromiseLike`: Attaches callbacks for the resolution and/or rejection of the Promise. ### AssetLoadContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetLoadContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetLoadContext } from "three-blocks/assets"; interface AssetLoadContext ``` **Purpose:** Declares AssetLoadContext as a public interface. It is exported from three-blocks/assets. Its declared surface covers attempt, reportProgress, and signal. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetLoadContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attempt: number` - `readonly reportProgress: (progress: number) => void` - `readonly signal: AbortSignalLike` ### AssetLoadError Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetLoadError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetLoadError } from "three-blocks/assets"; class AssetLoadError extends Error ``` **Purpose:** Declares AssetLoadError as a public class. It is exported from three-blocks/assets. Its declared surface covers assetName, assetType, attempts, causeValue, and code, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assetName: string` - `readonly assetType: string` - `readonly attempts: number` - `readonly causeValue: unknown` - `readonly code: AssetLoadErrorCode` - `constructor(options: {readonly code: AssetLoadErrorCode; readonly assetName: string; readonly assetType: string; readonly message: string; readonly attempts?: number; readonly cause?: unknown;})` ### AssetLoadErrorCode Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetLoadErrorCode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetLoadErrorCode } from "three-blocks/assets"; type AssetLoadErrorCode = 'aborted' | 'adapter-error' | 'filtered-optional' | 'filtered-required' | 'invalid-definition' | 'manager-disposed' | 'missing-adapter' | 'no-audio-source' ``` **Purpose:** Declares AssetLoadErrorCode as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetLoadErrorCode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetLoadOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetLoadOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetLoadOptions } from "three-blocks/assets"; interface AssetLoadOptions ``` **Purpose:** Declares AssetLoadOptions as a public interface. It is exported from three-blocks/assets. Its declared surface covers onProgress and signal. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetLoadOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly onProgress?: (progress: AssetProgress) => void` - `readonly signal?: AbortSignalLike` ### AssetLoaderRegistry Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetLoaderRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetLoaderRegistry } from "three-blocks/assets"; class AssetLoaderRegistry ``` **Purpose:** Declares AssetLoaderRegistry as a public class. It is exported from three-blocks/assets. Its declared surface covers adapters, describe, get, and has, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly adapters: TAdapters` - `constructor(adapters: TAdapters & AdapterConstraint)` - `describe(): Readonly>` - `get(type: string): UntypedAdapter | undefined` - `get>(type: TKey): TAdapters[TKey] | undefined` - `has(type: string): boolean` ### AssetManager Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetManager. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetManager } from "three-blocks/assets"; class AssetManager ``` **Purpose:** Declares AssetManager as a public class. It is exported from three-blocks/assets. Its declared surface covers cacheSnapshot, createScope, diff, disposed, and evict, plus 6 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and load. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `cacheSnapshot(): readonly AssetCacheEntrySnapshot[]` - `constructor(registry: AssetLoaderRegistry, options?: AssetManagerOptions)` - `createScope(): AssetScope`: Create one ownership scope per scene or other hot-replaceable lifetime. - `diff(previous: Readonly>, next: Readonly>): AssetManifestDiff` - `get disposed(): boolean` - `evict(key: string): boolean` - `lease>(manifest: TManifest, options?: AssetLoadOptions): Promise>>` - `load>(manifest: TManifest, options?: AssetLoadOptions): AssetLoad>`: Keep the returned request and call release(); use lease() for an explicit direct-await owner. - `readonly registry: AssetLoaderRegistry` - `replace>(current: AssetLoad, manifest: TManifest, options?: AssetLoadOptions): AssetLoad>` - `shutdown(): Promise` ### AssetManagerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetManagerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetManagerOptions } from "three-blocks/assets"; interface AssetManagerOptions ``` **Purpose:** Declares AssetManagerOptions as a public interface. It is exported from three-blocks/assets. Its declared surface covers concurrency, defaultWeight, device, includeFonts, and onDisposeError, plus 3 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetManagerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly concurrency?: number` - `readonly defaultWeight?: number` - `readonly device?: 'desktop' | 'mobile'` - `readonly includeFonts?: boolean` - `readonly onDisposeError?: (error: unknown) => void` - `readonly retry?: AssetRetry` - `readonly sleep?: AssetSleep` - `readonly supportedAudioFormats?: readonly string[]` ### AssetManifestDiff Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetManifestDiff. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetManifestDiff } from "three-blocks/assets"; interface AssetManifestDiff ``` **Purpose:** Declares AssetManifestDiff as a public interface. It is exported from three-blocks/assets. Its declared surface covers added, changed, removed, and unchanged. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetManifestDiff. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly added: readonly string[]` - `readonly changed: readonly string[]` - `readonly removed: readonly string[]` - `readonly unchanged: readonly string[]` ### AssetManifestForAdapters Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetManifestForAdapters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetManifestForAdapters } from "three-blocks/assets"; type AssetManifestForAdapters = Readonly>> ``` **Purpose:** Declares AssetManifestForAdapters as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetManifestForAdapters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetProgress Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetProgress. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetProgress } from "three-blocks/assets"; interface AssetProgress ``` **Purpose:** Declares AssetProgress as a public interface. It is exported from three-blocks/assets. Its declared surface covers asset, loadedWeight, progress, and totalWeight. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetProgress. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly asset?: string` - `readonly loadedWeight: number` - `readonly progress: number` - `readonly totalWeight: number` ### AssetResultForDefinition Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetResultForDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetResultForDefinition } from "three-blocks/assets"; type AssetResultForDefinition = false extends AssetRequiredFlag ? AssetValueForDefinition | undefined: AssetValueForDefinition ``` **Purpose:** Declares AssetResultForDefinition as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetResultForDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetResults Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetResults. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetResults } from "three-blocks/assets"; type AssetResults = {-readonly [TName in keyof TManifest]: AssetResultForDefinition;} ``` **Purpose:** Declares AssetResults as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetResults. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetRetry Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetRetry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetRetry } from "three-blocks/assets"; type AssetRetry = number | AssetRetryPolicy ``` **Purpose:** Declares AssetRetry as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetRetry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetRetryContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetRetryContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetRetryContext } from "three-blocks/assets"; interface AssetRetryContext ``` **Purpose:** Declares AssetRetryContext as a public interface. It is exported from three-blocks/assets. Its declared surface covers attempt, definition, and error. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetRetryContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attempt: number` - `readonly definition: AssetDefinition` - `readonly error: unknown` ### AssetRetryPolicy Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetRetryPolicy. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetRetryPolicy } from "three-blocks/assets"; interface AssetRetryPolicy ``` **Purpose:** Declares AssetRetryPolicy as a public interface. It is exported from three-blocks/assets. Its declared surface covers delayMs, retries, and shouldRetry. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetRetryPolicy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly delayMs?: number | ((context: AssetRetryContext) => number)` - `readonly retries: number`: Retry count after the initial attempt. - `readonly shouldRetry?: (context: AssetRetryContext) => boolean` ### AssetScope Kind: class; canonical: https://threejs-blocks.com/docs/api/AssetScope. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { AssetScope } from "three-blocks/assets"; class AssetScope ``` **Purpose:** Scene-lifetime facade used as `context.assets`. It preserves the ergonomic direct-await API while retaining every request until the owning scene is disposed. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, load, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `get activeLoads(): number` - `constructor(manager: AssetManager)` - `dispose(): void` - `get disposed(): boolean` - `load>(manifest: TManifest, options?: AssetLoadOptions): Promise>` ### AssetSleep Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetSleep. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetSleep } from "three-blocks/assets"; type AssetSleep = (milliseconds: number, signal: AbortSignalLike) => Promise ``` **Purpose:** Declares AssetSleep as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetSleep. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetSource } from "three-blocks/assets"; interface AssetSource ``` **Purpose:** Declares AssetSource as a public interface. It is exported from three-blocks/assets. Its declared surface covers bytes, format, and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bytes?: number` - `readonly format?: string` - `readonly url: string` ### AssetUrl Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetUrl. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetUrl } from "three-blocks/assets"; type AssetUrl = string | readonly string[] ``` **Purpose:** Declares AssetUrl as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetUrl. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetValueForDefinition Kind: type; canonical: https://threejs-blocks.com/docs/api/AssetValueForDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetValueForDefinition } from "three-blocks/assets"; type AssetValueForDefinition = AssetAdapterResult> ``` **Purpose:** Declares AssetValueForDefinition as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetValueForDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### AssetVariant Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetVariant. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetVariant } from "three-blocks/assets"; interface AssetVariant ``` **Purpose:** Declares AssetVariant as a public interface. It is exported from three-blocks/assets. Its declared surface covers bytes, disabled, sources, and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetVariant. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bytes?: number` - `readonly disabled?: boolean` - `readonly sources?: readonly TSource[]` - `readonly url?: TUrl` ### AssetVariants Kind: interface; canonical: https://threejs-blocks.com/docs/api/AssetVariants. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AssetVariants } from "three-blocks/assets"; interface AssetVariants ``` **Purpose:** Declares AssetVariants as a public interface. It is exported from three-blocks/assets. Its declared surface covers desktop and mobile. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AssetVariants. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly desktop?: AssetVariant` - `readonly mobile?: AssetVariant` ### AudioAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/AudioAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AudioAssetDefinition } from "three-blocks/assets"; interface AudioAssetDefinition extends AssetDefinition<'audio', string, AssetSource> ``` **Purpose:** Declares AudioAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers preferredFormats, selectedFormat, sources, and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for AudioAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly preferredFormats?: readonly string[]` - `readonly selectedFormat?: string`: Set by AssetManager after supported-format fallback selection. - `readonly sources?: readonly AssetSource[]` - `readonly url?: string` ### AutomaticShaderHydration Kind: interface; canonical: https://threejs-blocks.com/docs/api/AutomaticShaderHydration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { AutomaticShaderHydration } from "three-blocks/shaders"; interface AutomaticShaderHydration ``` **Purpose:** Declares AutomaticShaderHydration as a public interface. It is exported from three-blocks/shaders. Its declared surface covers dispose, ready, and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(): void` - `readonly ready: Promise` - `readonly scene: string` ### BAKED_MOTION_TYPE Kind: variable; canonical: https://threejs-blocks.com/docs/api/BAKED_MOTION_TYPE. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BAKED_MOTION_TYPE } from "three-blocks/baked-motion"; const BAKED_MOTION_TYPE: "utsubo-utsbv" ``` **Purpose:** Persisted Baked Motion package discriminator. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BAKED_MOTION_TYPE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BAKED_MOTION_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/BAKED_MOTION_VERSION. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BAKED_MOTION_VERSION } from "three-blocks/baked-motion"; const BAKED_MOTION_VERSION: 3 ``` **Purpose:** Persisted Baked Motion manifest version understood by this runtime. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BAKED_MOTION_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BVHVolumeConstraint Kind: variable; canonical: https://threejs-blocks.com/docs/api/BVHVolumeConstraint. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BVHVolumeConstraint } from "three-blocks/sdf-raymarching"; const BVHVolumeConstraint: BVHVolumeConstraintConstructor ``` **Purpose:** Direct BVH particle-volume constraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `apply(renderer: THREE.Renderer, positions: SDFParticleVectorStorage, velocities: SDFParticleVectorStorage, particleCount: number, options?: SDFBoundaryApplyOptions): Promise`: Submit one in-place boundary response after all preceding simulation writes. - `new (options: BVHVolumeConstraintOptions): BVHVolumeConstraint`: Construct and validate a direct-query boundary constraint. - `containment: boolean`: Whether triangle mode keeps particles inside the volume. - `damping: number`: Normal-velocity damping used by subsequent dispatches. - `dispose(): void`: Release packed BVH data and cached passes without disposing borrowed inputs. - `maxSearchDistance: number`: Largest local-space query distance. - `readonly mode: BVHVolumeConstraintMode`: Active query strategy fixed at construction. - `pointRadius: number`: Point-shell radius used in `points` mode. - `setWorldMatrix(matrix: THREE.Matrix4): void`: Copy a local-to-world transform and refresh its cached inverse. - `stiffness: number`: Penetration correction strength used by subsequent dispatches. - `threshold: number`: Triangle-surface offset used in `triangles` mode. - `updateBVH(geometry: THREE.BufferGeometry, bvh?: GeometryBVH | null): void`: Replace borrowed geometry/BVH inputs and invalidate cached query passes. ### BVHVolumeConstraintMode Kind: type; canonical: https://threejs-blocks.com/docs/api/BVHVolumeConstraintMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BVHVolumeConstraintMode } from "three-blocks/sdf-raymarching"; type BVHVolumeConstraintMode = 'triangles' | 'points' ``` **Purpose:** Direct BVH query strategy used by BVHVolumeConstraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BVHVolumeConstraintMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### BVHVolumeConstraintOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/BVHVolumeConstraintOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BVHVolumeConstraintOptions } from "three-blocks/sdf-raymarching"; interface BVHVolumeConstraintOptions ``` **Purpose:** Construction configuration for BVHVolumeConstraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BVHVolumeConstraintOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `bvh?: GeometryBVH | null | undefined`: Caller-owned BVH, or `null` to resolve `geometry.boundsTree`. - `containment?: boolean | undefined`: Keep particles inside triangle geometry when true, or outside when false. - `damping?: number | undefined`: Normal-velocity damping applied during collision response. - `geometry: THREE.BufferGeometry`: Caller-owned source geometry referenced until the constraint is updated. - `maxSearchDistance?: number | undefined`: Largest local-space distance searched by a BVH query. - `mode?: BVHVolumeConstraintMode | undefined`: Use signed triangle queries or point-shell range queries. - `pointRadius?: number | undefined`: Point-shell radius used only in `points` mode. - `stiffness?: number | undefined`: Penetration correction strength. - `threshold?: number | undefined`: Triangle-surface distance offset. - `worldMatrix?: THREE.Matrix4 | null | undefined`: Optional initial local-to-world transform copied during construction. ### BakedMotion Kind: variable; canonical: https://threejs-blocks.com/docs/api/BakedMotion. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BakedMotion } from "three-blocks/baked-motion"; const BakedMotion: BakedMotionConstructor ``` **Purpose:** Runtime-only Baked Motion playback facade. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, pause, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: https://threejs-blocks.com/examples/webgpu_baked_motion_rotation, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_baked_motion_timeline. - `readonly buffering: boolean`: Whether timeline playback is holding its last complete frame while the next sample loads. - `new (manifestURL: string | URL, options?: BakedMotionOptions): BakedMotion`: Create a Baked Motion player for a manifest URL and optional runtime controls. - `dispose(): void`: Release owned decoders, textures, geometry, and material. Idempotent; borrowed renderer, mesh, geometry, and material resources are not disposed. - `readonly frameReady: Promise`: Resolves when the most recently requested streamed sample has reached its slots. - `getDiagnostics(): Readonly`: Return a deeply immutable point-in-time diagnostic snapshot. - `loop: boolean`: Whether timeline playback wraps at the end of the clip. - `readonly manifest: BakedMotionManifest | null`: Validated manifest, available after BakedMotion.ready resolves. - `readonly material: BakedMotionMaterial`: Driven material; borrowed when supplied in options, otherwise owned by this instance. - `readonly mesh: BakedMotionMesh`: Renderable Three.js mesh to add directly to a scene. - `readonly node: BakedMotionImplementation['node']`: The presented view as a texture-style node — the map-consumable form of Baked Motion (decoded `VideoFrame`s in `THREE.VideoFrameTexture` slots, blended by the presentation weights). Assign it like any node: `material.colorNode = motion.node`. Requires `await motion.ready`. - `readonly parameters: BakedMotionParameters | null`: Last mode-specific parameters submitted to the sampler. - `pause(): this`: Pause timeline advancement while retaining the current decoded sample. - `play(): this`: Resume timeline advancement. - `playbackRate: number`: Timeline playback multiplier. - `readonly playing: boolean`: Whether timeline playback advances during BakedMotion.update. - `readonly ready: Promise`: Resolves after manifest validation, media initialization, and initial sampling. Rejects on fetch, format, codec, or explicit preload-budget failure. - `resume(): Promise`: Re-admit decoder sessions and present the newest parameters into retained textures. - `sample: BakedMotionImplementation['sample']`: `motion.node` at a custom coordinate. - `setPointer(x: number, y: number): this`: Set a tilt target in normalized device coordinates; call `update()` to ease toward it. - `setTime(seconds: number): this`: Set timeline time and request its decoded sample; valid only for timeline manifests. - `setView(camera: BakedMotionViewSource): this`: Sample rotation parameters from a camera/object position; valid only for rotation manifests. - `readonly state: BakedMotionState`: Current observable lifecycle state. - `readonly strategy: BakedMotionResolvedStrategy | null`: Resolved loading strategy, available after initialization selects a path. - `suspend(): this`: Park decoder sessions while retaining the current texture contents. - `readonly time: number`: Current timeline time in seconds. - `update(deltaSeconds: number): this`: Advance timeline or pointer easing by elapsed seconds. Call once after input/control updates and before rendering the frame. ### BakedMotionDelivery Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionDelivery. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionDelivery } from "three-blocks/baked-motion"; type BakedMotionDelivery = 'full' | 'segments' ``` **Purpose:** Media delivery policy: one whole-file request per track (default) or opt-in verified range segments. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionDelivery. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionDiagnostics Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionDiagnostics. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionDiagnostics } from "three-blocks/baked-motion"; type BakedMotionDiagnostics = BakedMotionDiagnosticsImplementation ``` **Purpose:** Immutable local-only runtime diagnostic snapshot. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionDiagnostics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionError Kind: class; canonical: https://threejs-blocks.com/docs/api/BakedMotionError. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BakedMotionError } from "three-blocks/baked-motion"; class BakedMotionError extends Error ``` **Purpose:** Stable Baked Motion failure carrying a point-in-time immutable diagnostic snapshot. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. - `readonly cause?: unknown`: Optional underlying error or rejected value. - `readonly code: BakedMotionErrorCode`: Stable machine-readable failure category. - `constructor(code: BakedMotionErrorCode, message: string, diagnostics: BakedMotionDiagnostics, options?: {cause?: unknown;})`: Create a typed Baked Motion failure with an immutable diagnostic snapshot. - `readonly diagnostics: Readonly`: Immutable runtime state captured when the failure occurred. ### BakedMotionErrorCode Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionErrorCode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionErrorCode } from "three-blocks/baked-motion"; type BakedMotionErrorCode = BakedMotionErrorCodeImplementation ``` **Purpose:** Stable code carried by a failed Baked Motion operation. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionErrorCode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionFetch Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionFetch. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionFetch } from "three-blocks/baked-motion"; type BakedMotionFetch = (input: string, init?: RequestInit) => Promise ``` **Purpose:** Injectable network function used to load manifests and `.af` tracks. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionFetch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionFetchResponse Kind: interface; canonical: https://threejs-blocks.com/docs/api/BakedMotionFetchResponse. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionFetchResponse } from "three-blocks/baked-motion"; interface BakedMotionFetchResponse ``` **Purpose:** Minimal response consumed by Baked Motion's injectable fetch implementation. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionFetchResponse. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. - `arrayBuffer(): Promise`: Read an encoded media response body. - `readonly body?: ReadableStream | null`: Optional streaming body used to enforce full-response byte caps before retention. - `readonly headers?: {get(name: string): string | null;}`: Optional readable response headers used to validate exact byte ranges and pin ETags. - `json(): Promise`: Read and decode a JSON response body. - `readonly ok: boolean`: Whether the response completed with a successful HTTP status. - `readonly status: number`: Numeric HTTP status used in load failures. - `text?(): Promise`: Optional raw text reader used to enforce the manifest byte cap before parsing. ### BakedMotionFrameSample Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionFrameSample. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionFrameSample } from "three-blocks/baked-motion"; type BakedMotionFrameSample = BakedMotionFrameSampleImplementation ``` **Purpose:** One- or two-dimensional stored-frame sample selected from a manifest. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionFrameSample. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionGeometry Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionGeometry. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionGeometry } from "three-blocks/baked-motion"; type BakedMotionGeometry = THREE.BufferGeometry ``` **Purpose:** Geometry displayed by a Baked Motion instance. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionGeometry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionManifest. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionManifest } from "three-blocks/baked-motion"; type BakedMotionManifest = BakedMotionManifestImplementation ``` **Purpose:** Validated, versioned Baked Motion runtime manifest. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionMaterial Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionMaterial } from "three-blocks/baked-motion"; type BakedMotionMaterial = THREE.NodeMaterial ``` **Purpose:** Node material driven by decoded Baked Motion colour, alpha, and depth. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionMaterial. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionMesh Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionMesh. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionMesh } from "three-blocks/baked-motion"; type BakedMotionMesh = THREE.Mesh ``` **Purpose:** Scene object exposed as the renderable Baked Motion output. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionMesh. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/BakedMotionOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionOptions } from "three-blocks/baked-motion"; interface BakedMotionOptions ``` **Purpose:** Runtime construction and playback options for BakedMotion. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. - `admissionTimeoutMs?: number`: Maximum wall-clock milliseconds allowed for first decoder output after submission. - `billboard?: boolean`: Face the camera via world-up billboarding. Defaults to true only for the owned plane. - `cpuUpload?: boolean`: Use bounded CPU-backed data-texture slots instead of VideoFrameTexture uploads. - `delivery?: BakedMotionDelivery`: Media delivery policy. Defaults to `'full'`: one verified whole-file request per selected track. `'segments'` opts in to demand-driven verified HTTP range requests — only for servers known to honor `Range` and interactions that tolerate on-demand fetch latency. - `fetchImpl?: BakedMotionFetch`: Custom manifest/media fetch implementation, primarily for controlled runtimes. - `geometry?: BakedMotionGeometry`: Borrowed geometry; omitted geometry is created and owned by Baked Motion. - `hardwareAcceleration?: HardwareAcceleration`: WebCodecs hardware-acceleration preference. - `height?: number`: World-space height of the generated billboard geometry. - `loop?: boolean`: Whether timeline playback wraps at the manifest duration. - `material?: BakedMotionMaterial`: Borrowed node material to drive; never disposed by Baked Motion. - `maxFullFileBytes?: number`: Maximum complete `.af` resource accepted. - `maxRenditionWidth?: number`: Highest coded rendition width eligible in automatic mode. - `maxTextureArrayLayers?: number`: Maximum texture-array layers accepted by the explicit preload strategy. - `mesh?: BakedMotionMesh`: Borrowed mesh whose original geometry and material remain caller-owned. - `name?: string`: Optional Three.js object name assigned to the renderable mesh. - `playbackRate?: number`: Timeline playback multiplier. - `playing?: boolean`: Whether timeline playback starts in the playing state. - `renderer?: BakedMotionRenderer`: Borrowed renderer used only for texture-array uploads; never disposed. - `rendition?: 'auto' | string`: Automatic ordered fallback, or one exact normalized rendition ID. - `seekInterval?: number`: Opt into the fixed grid re-seek pacer. Omit for decode-time adaptive pacing; any supplied value preserves fixed cadence behavior, and `0` keeps every seek immediate. - `strategy?: BakedMotionStrategy`: Streaming policy; `auto` selects bounded streaming unless preload is explicitly requested. - `vramBudget?: number`: Maximum estimated texture-array bytes accepted by the explicit preload strategy. - `writeDepth?: boolean`: Whether decoded depth is written into the material depth node. ### BakedMotionParameterValues Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionParameterValues. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionParameterValues } from "three-blocks/baked-motion"; type BakedMotionParameterValues = BakedMotionParameterValuesImplementation ``` **Purpose:** Parameter values accepted when mapping a manifest sample to stored frames. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionParameterValues. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionParameters Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionParameters. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionParameters } from "three-blocks/baked-motion"; type BakedMotionParameters = BakedMotionParametersImplementation ``` **Purpose:** Current mode-specific parameters sampled by a Baked Motion instance. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionRenderer Kind: interface; canonical: https://threejs-blocks.com/docs/api/BakedMotionRenderer. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionRenderer } from "three-blocks/baked-motion"; interface BakedMotionRenderer ``` **Purpose:** Renderer operations used by preload and v3 paged-atlas publication. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: render. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. - `readonly backend?: unknown`: Optional renderer backend used to inspect the texture-array layer limit. - `copyTextureToTexture(source: THREE.Texture, destination: THREE.Texture, sourceRegion?: THREE.Box2 | THREE.Box3 | null, destinationPosition?: THREE.Vector2 | THREE.Vector3 | null, sourceLevel?: number, destinationLevel?: number): void`: Copy a decoded texture into one layer of the owned preload texture array. - `getActiveCubeFace?(): number`: Return the active cube-map face for render-target restoration. - `getActiveMipmapLevel?(): number`: Return the active mip level for render-target restoration. - `getRenderTarget?(): THREE.RenderTarget | null`: Return the renderer's current render target. - `initRenderTarget?(target: THREE.RenderTarget): void`: Optional owned-atlas GPU-cache surface. - `initTexture(texture: THREE.Texture): void`: Initialize a texture before copying decoded frames into it. - `render?(scene: THREE.Object3D, camera: THREE.Camera): void | Promise`: Render one atlas publication pass. - `setRenderTarget?(target: THREE.RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void`: Select the render target used while publishing an owned atlas page. ### BakedMotionResolvedStrategy Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionResolvedStrategy. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionResolvedStrategy } from "three-blocks/baked-motion"; type BakedMotionResolvedStrategy = Exclude ``` **Purpose:** Concrete loading strategy selected after manifest and device checks. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionResolvedStrategy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionRotationParameters Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionRotationParameters. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionRotationParameters } from "three-blocks/baked-motion"; type BakedMotionRotationParameters = BakedMotionRotationParametersImplementation ``` **Purpose:** View-rotation parameters currently sampled by the runtime. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionRotationParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionState Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionState. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionState } from "three-blocks/baked-motion"; type BakedMotionState = BakedMotionStateImplementation ``` **Purpose:** Stable host-facing Baked Motion lifecycle state. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionStrategy Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionStrategy. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionStrategy } from "three-blocks/baked-motion"; type BakedMotionStrategy = 'auto' | 'stream' | 'preload' ``` **Purpose:** Runtime loading strategy requested by a Baked Motion consumer. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionStrategy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionTiltParameters Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionTiltParameters. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionTiltParameters } from "three-blocks/baked-motion"; type BakedMotionTiltParameters = BakedMotionTiltParametersImplementation ``` **Purpose:** Pointer-tilt parameters currently sampled by the runtime. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionTiltParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionTimelineParameters Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionTimelineParameters. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionTimelineParameters } from "three-blocks/baked-motion"; type BakedMotionTimelineParameters = BakedMotionTimelineParametersImplementation ``` **Purpose:** Timeline-mode playback parameters currently sampled by the runtime. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionTimelineParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BakedMotionViewSource Kind: type; canonical: https://threejs-blocks.com/docs/api/BakedMotionViewSource. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BakedMotionViewSource } from "three-blocks/baked-motion"; type BakedMotionViewSource = BakedMotionViewSourceImplementation ``` **Purpose:** Camera, object, or vector-like input accepted by BakedMotion.setView. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BakedMotionViewSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### BatchedMSDFText Kind: class; canonical: https://threejs-blocks.com/docs/api/BatchedMSDFText. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { BatchedMSDFText } from "three-blocks"; import { BatchedMSDFText } from "three-blocks/msdf-text"; class BatchedMSDFText extends THREE.Mesh ``` **Purpose:** Many independent MSDF text blocks in a single draw call and a single atlas bind. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: https://threejs-blocks.com/examples/webgpu_text_msdf_batched. - `addText(options?: BatchedMSDFTextAddOptions): number`: Adds a text block as a batched member. - `constructor(options?: BatchedMSDFTextOptions)`: Creates a fixed-capacity text batch and takes ownership of its generated geometry and material. The supplied font metrics and atlas texture remain caller-owned; disposal ownership of a supplied custom material transfers to the batch. - `dispose(): void`: Frees the owned GPU geometry and material. The caller-owned atlas texture is not disposed. A caller-supplied custom material is also disposed because it becomes the batch material. - `get font(): MSDFFont | null`: Parsed atlas metrics shared by every member. The caller retains ownership. - `set font(value: MSDFFont | null)`: Parsed atlas metrics shared by every member. The caller retains ownership. - `getColorAt(slot: number, target?: THREE.Color): THREE.Color`: Copies a member's color into a caller-provided target, or a new color when omitted. - `getMatrixAt(slot: number, target?: THREE.Matrix4): THREE.Matrix4`: Copies a member's transform into a caller-provided target, or a new matrix when omitted. - `getOpacityAt(slot: number): number`: Reads a member's opacity multiplier. - `getStringAt(slot: number): string`: Reads a member's current self-layout content without exposing its mutable record. - `hasText(slot: number): boolean`: Reports whether a live member occupies a slot. - `readonly isBatchedMSDFText: boolean`: Runtime type guard for batched MSDF text meshes. - `readonly isScreenSpace: boolean`: Whether member transforms use CSS-pixel viewport coordinates. - `get layoutInfo(): Readonly`: Read-only glyph and member counts from the most recent synchronous repack. - `get maxGlyphCount(): number`: Fixed maximum number of drawable glyphs across all members. - `get maxTextCount(): number`: Fixed maximum number of live text members. - `get memberCount(): number`: Number of live text members. - `onBeforeRender(): void`: Coalesces pending member layouts immediately before Three.js renders the mesh. - `get opacity(): number`: Opacity multiplier shared by every member in the batch. - `set opacity(value: number)`: Opacity multiplier shared by every member in the batch. - `removeText(slot: number): this`: Removes a member and frees its slot. - `setColorAt(slot: number, color: THREE.ColorRepresentation): this`: Sets a member's color. Cheap — writes a storage buffer, no repack. - `setLayoutAt(slot: number, options?: BatchedMSDFTextLayoutPatch): this`: Patches a member's layout-affecting properties (fontSize, align, anchors, wrapping…), triggering a repack. - `setLinesAt(slot: number, lines: readonly MSDFTextLineInput[] | null): this`: Sets pre-broken line content for a member, triggering a repack. - `setMap(map: THREE.Texture | null): void`: Binds the atlas texture (normalizing its sampler state for MSDF). - `setMatrixAt(slot: number, matrix: THREE.Matrix4): this`: Sets a member's transform (batch-local space). Cheap — writes a storage buffer, no repack. - `setOpacityAt(slot: number, opacity: number): this`: Sets a member's opacity. Cheap — writes a storage buffer, no repack. - `setScreenOffset(x: number, y: number): void`: screenSpace: batch origin in the viewport (CSS px, y-down top-left origin). - `setTextAt(slot: number, value: unknown): this`: Replaces a member's content, triggering a repack. - `setViewport(width: number, height: number): void`: screenSpace: the canvas CSS pixel size. - `update(): void`: Re-lays out any dirty members and rewrites the packed glyph buffers. Runs automatically before rendering when something changed; call directly to force a synchronous rebuild. - `get weightBias(): number`: Signed fake-weight bias shared by the batch; positive values make strokes bolder. - `set weightBias(value: number)`: Signed fake-weight bias shared by the batch; positive values make strokes bolder. ### BatchedMSDFTextAddOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/BatchedMSDFTextAddOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BatchedMSDFTextAddOptions } from "three-blocks/msdf-text"; interface BatchedMSDFTextAddOptions ``` **Purpose:** Content, layout, transform, and appearance for one new batch member. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BatchedMSDFTextAddOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `align?: MSDFTextAlign | undefined`: Horizontal alignment within the maximum width. - `anchorX?: MSDFTextAnchorX | undefined`: Horizontal origin for the laid-out member. - `anchorY?: MSDFTextAnchorY | undefined`: Vertical origin for the laid-out member. - `color?: THREE.ColorRepresentation | undefined`: Initial member color. - `fontSize?: number | undefined`: World units per em, or CSS pixels per em in screen-space mode. - `letterSpacing?: number | undefined`: Additional spacing between adjacent glyphs. - `lineHeight?: number | undefined`: Line-box height, or zero to use the font's default. - `lines?: readonly MSDFTextLineInput[] | null | undefined`: Pre-broken lines that override self-layout while non-null. - `matrix?: THREE.Matrix4 | null | undefined`: Complete member transform in batch-local space. - `maxWidth?: number | undefined`: Maximum line width used by self-layout. - `opacity?: number | undefined`: Initial member opacity. - `position?: BatchedMSDFTextPosition | null | undefined`: Translation shorthand used when no matrix is supplied. - `text?: unknown`: Text content for self-layout mode. ### BatchedMSDFTextLayoutInfo Kind: interface; canonical: https://threejs-blocks.com/docs/api/BatchedMSDFTextLayoutInfo. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BatchedMSDFTextLayoutInfo } from "three-blocks/msdf-text"; interface BatchedMSDFTextLayoutInfo ``` **Purpose:** Read-only packing statistics from the most recent update. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BatchedMSDFTextLayoutInfo. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `glyphCount: number`: Number of drawable glyph instances packed into the batch. - `memberCount: number`: Number of live text members. ### BatchedMSDFTextLayoutPatch Kind: interface; canonical: https://threejs-blocks.com/docs/api/BatchedMSDFTextLayoutPatch. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BatchedMSDFTextLayoutPatch } from "three-blocks/msdf-text"; interface BatchedMSDFTextLayoutPatch ``` **Purpose:** Layout fields that can be changed without replacing member content. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BatchedMSDFTextLayoutPatch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `align?: MSDFTextAlign | undefined`: Horizontal alignment within the maximum width. - `anchorX?: MSDFTextAnchorX | undefined`: Horizontal origin for the laid-out member. - `anchorY?: MSDFTextAnchorY | undefined`: Vertical origin for the laid-out member. - `fontSize?: number | undefined`: World units per em, or CSS pixels per em in screen-space mode. - `letterSpacing?: number | undefined`: Additional spacing between adjacent glyphs. - `lineHeight?: number | undefined`: Line-box height, or zero to use the font's default. - `maxWidth?: number | undefined`: Maximum line width used by self-layout. ### BatchedMSDFTextOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/BatchedMSDFTextOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BatchedMSDFTextOptions } from "three-blocks/msdf-text"; interface BatchedMSDFTextOptions ``` **Purpose:** Construction options for BatchedMSDFText. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BatchedMSDFTextOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `font?: MSDFFont | null | undefined`: Parsed atlas metrics shared by every batch member. - `map?: THREE.Texture | null | undefined`: Shared MSDF atlas texture. The caller retains ownership and disposes it. - `material?: THREE.Material | null | undefined`: Optional advanced material override whose disposal ownership transfers to the batch. - `maxGlyphCount?: number | undefined`: Fixed maximum number of drawable glyphs across all members. - `maxTextCount?: number | undefined`: Fixed maximum number of independently controlled text members. - `opacity?: number | undefined`: Initial opacity multiplier shared by the batch. - `pixelSnap?: boolean | undefined`: screenSpace only: snap glyph origins to physical pixels (default true). Disable for smoothly animated text. - `screenSpace?: boolean | undefined`: Whether member transforms use CSS-pixel viewport coordinates. ### BatchedText Kind: class; canonical: https://threejs-blocks.com/docs/api/BatchedText. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { BatchedText } from "three-blocks/experimental/runtime-sdf-text"; class BatchedText extends Text ``` **Purpose:** ### WebGL Support has been temporarily disabled. **Status:** Experimental through the curated Runtime SDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/runtime-sdf-text. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/runtime-sdf-text Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. - `add(...objs: Object3D[]): this`: Add objects to batch. `Text` instances become batched members. Non-Text objects are added to scene graph normally. - `addText(text: Text): number`: Register a Text instance as a batched member. Returns an instance ID that can be used with setMatrixAt, setColorAt, etc. - `attachGUI(folder: BatchedTextGUIFolder | null | undefined): void`: Attach a simple GUI folder with controls for culling and LOD settings. Compatible with lil-gui, dat.gui, and Three.js Inspector. Note: Culling options are only shown on WebGPU backend. - `get billboarding(): boolean`: Enable yaw-only billboarding so text always faces the camera. When enabled, text rotates around the Y-axis to face the camera while remaining upright. - `set billboarding(v: boolean)`: Enable yaw-only billboarding so text always faces the camera. When enabled, text rotates around the Y-axis to face the camera while remaining upright. - `constructor(maxTextCount?: number | null, maxGlyphCount?: number | null, material?: BatchedTextMaterial | null)`: Create a batched text container. - `count: number`: The number of instances of this mesh. Can only be used with WebGPURenderer. - `culler: BatchedTextCuller | null` - `cullerCapacity: number` - `dispose(): void`: Dispose resources associated with this helper and detach debug UI. - `disposeGUI(): void`: Destroy the attached GUI and clear reference. - `getColorAt(instanceId: number, color: THREE.Color): THREE.Color`: Returns the color of the defined text instance. - `getGlyphAt(instanceId: number, target?: BatchedTextGlyphData): BatchedTextGlyphData | null`: Returns glyph data for the given text instance without triggering a full sync. Only the first glyph range for the member is returned; multi-glyph members are supported via glyphOffset/count. - `getMatrixAt(instanceId: number, matrix: THREE.Matrix4): THREE.Matrix4`: Returns the local transformation matrix of the defined text instance. - `getTextAt(instanceId: number): Text | null`: Get the Text instance at the given instance ID. - `getTextBoundingSphereAt(instanceId: number): BatchedTextBoundingSphere | null`: Get the bounding sphere for a specific text instance (local space). - `initCuller(renderer: Renderer): BatchedTextCuller | null`: Initialize the GPU culler early (before first render). Useful when you need to access `culler` immediately. - `get instanceMatrix(): BatchedTextMatrixAttribute | null` - `set instanceMatrix(attribute: BatchedTextMatrixAttribute | null)` - `get isCullingActive(): boolean`: Returns true if GPU culling is active (WebGPU only, and culling requested). - `get isWebGL(): boolean | null`: Returns true if running on WebGL backend (no compute shader support). Returns null if backend hasn't been detected yet. - `material: BatchedTextMaterial`: An instance of material derived from the Material base class or an array of materials, defining the object's appearance. - `needsUpdate: boolean` - `get perObjectFrustumCulled(): boolean` - `set perObjectFrustumCulled(v: boolean)` - `get perTextBoundingBox(): boolean`: Get or set per-text bounding box mode. When true, each text instance gets its own bounding sphere for more accurate culling. When false (default), uses the maximum bounding sphere of all instances for faster culling. - `set perTextBoundingBox(value: boolean)`: Get or set per-text bounding box mode. When true, each text instance gets its own bounding sphere for more accurate culling. When false (default), uses the maximum bounding sphere of all instances for faster culling. - `remove(...objs: Object3D[]): this`: Remove objects from batch. - `removeText(text: Text): void`: Unregister a Text instance from batch. - `setColorAt(instanceId: number, color: ColorRepresentation): this`: Sets the given color to the defined text instance. - `setCullingOptions(options: Partial): this`: Configure GPU frustum culling and distance LOD without reaching into internal state. Omitted fields retain their current values. - `setGlyphAt(instanceId: number, glyph: BatchedTextGlyphUpdate | null | undefined): this`: Quickly update glyph data (atlas index, bounds, letter index) for a specific text instance without triggering a full text sync/layout. Useful for single-glyph members such as counters. - `setMatrixAt(instanceId: number, matrix: THREE.Matrix4): this`: Sets the given local transformation matrix to the defined text instance. This updates the text's matrix and marks it for update. - `staticMode: boolean` - `sync(callback?: TextSyncCallback | null, renderer?: Renderer): void`: Synchronize all member `Text` instances. Triggers repacking of instance attributes when any member has changed, and rebuilds glyph data arrays. - `updateBounds(): void`: Recompute bounding volumes from all member bounds. - `updateMatrixWorld(force?: boolean): void`: Update world matrices and recompute bounds. - `updateMemberMatrixWorld(text: Text): void`: Update a single member's instance matrix in the storage buffer using its current world matrix. Does not recompute style parameters. ### BinaryAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/BinaryAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { BinaryAssetDefinition } from "three-blocks/assets"; interface BinaryAssetDefinition extends AssetDefinition<'binary', string, never> ``` **Purpose:** Declares BinaryAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BinaryAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly url: string` ### Boids Kind: variable; canonical: https://threejs-blocks.com/docs/api/Boids. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { Boids } from "three-blocks"; import { Boids } from "three-blocks/boids"; const Boids: BoidsConstructor ``` **Purpose:** Stable declaration-facing façade for the Boids GPU engine. **Status:** Stable through the curated Boids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/boids. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/boids Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d. - `new (options?: BoidsOptions): Boids`: Create a flock and allocate its engine-owned GPU storage. Throws: RangeError — If an option describes an invalid capacity or timestep; TypeError — If an external initial-position source is incompatible. - `detachSpatialGrid(): this`: Release an engine-created neighbor grid and return to the quadratic neighbor pass. The operation is safe when no grid is enabled and does not dispose caller resources. - `dispose(): void`: Release engine-owned GPU storage, compute passes, and any internally created grid. The renderer, external grids, constraints, initial positions, mesh, geometry, material, and interaction world remain caller-owned. The method is idempotent; do not step afterward. - `readonly is3D: boolean`: Whether the flock is simulated in three dimensions. - `readonly particleCount: number`: Number of live agents advanced by each step. - `setDomainDimensions(dimensions: Vector3): this`: Resize the axis-aligned simulation domain and synchronize neighbor acceleration. Call between frames, before the next Boids.step. - `setSpatialGridEnabled(enabled: boolean): this`: Enable or disable engine-owned neighbor-grid acceleration. Reconfiguration is synchronous and should happen between frame steps. - `step(renderer: Renderer, externalDeltaSeconds?: number | null): Promise`: Advance GPU state for one host frame. Call after updating controls and interaction inputs, await completion, then render. The first call may initialize the renderer and copy initial positions. ### BoidsInitialPositions Kind: type; canonical: https://threejs-blocks.com/docs/api/BoidsInitialPositions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BoidsInitialPositions } from "three-blocks/boids"; type BoidsInitialPositions = StorageBufferAttribute | StorageInstancedBufferAttribute ``` **Purpose:** GPU storage accepted as the initial position source for a flock. **Status:** Stable through the curated Boids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BoidsInitialPositions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/boids. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/boids Direct example imports: none recorded. ### BoidsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/BoidsOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { BoidsOptions } from "three-blocks/boids"; interface BoidsOptions ``` **Purpose:** Stable construction options for a GPU flock. **Status:** Stable through the curated Boids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BoidsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/boids. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/boids Direct example imports: none recorded. - `alignment?: number | undefined`: Alignment radius, relative to the domain by default. - `cohesion?: number | undefined`: Cohesion radius, relative to the domain by default. - `count?: number | undefined`: Number of simulated agents; values are rounded up internally for GPU dispatch. - `debug?: boolean | undefined`: Whether to collect optional implementation diagnostics; disabled by default. - `domainDimensions?: Vector3 | undefined`: Axis-aligned dimensions of the simulation domain in world units. - `fixedTimeStep?: number | null | undefined`: Fixed simulation interval in seconds, or `null` to use the measured frame interval. - `initialPositions?: BoidsInitialPositions | null | undefined`: Caller-owned GPU positions copied into engine-owned storage during first use. - `is3D?: boolean | undefined`: Whether agents move in three dimensions; `false` constrains motion to the XY plane. - `maxFrameDelta?: number | undefined`: Maximum accepted host frame interval in seconds. - `maxSubsteps?: number | undefined`: Maximum fixed simulation steps performed for one host frame. - `randomSeed?: readonly [number, number] | null | undefined`: Two-component deterministic seed used for initial headings and positions. - `separation?: number | undefined`: Separation radius, relative to the domain by default. - `speedLimit?: number | undefined`: Maximum speed, interpreted relative to the domain when relative parameters are enabled. - `timeScale?: number | undefined`: Multiplier applied to simulation time without changing the host frame delta. - `useDirection?: boolean | undefined`: Whether the engine computes smoothed headings for its internal render integration. - `useMatrices?: boolean | undefined`: Whether the engine computes per-agent transforms for its internal render integration. - `useRelativeParameters?: boolean | undefined`: Whether flock distances and speed scale with the average domain dimension. - `useSpatialGrid?: boolean | undefined`: Whether to use neighbor-grid acceleration instead of the quadratic fallback. ### BrowserMessageEndpoint Kind: interface; canonical: https://threejs-blocks.com/docs/api/BrowserMessageEndpoint. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { BrowserMessageEndpoint } from "three-blocks/worker"; interface BrowserMessageEndpoint ``` **Purpose:** Structural browser endpoint accepted without application-side casts. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: start and close. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `addEventListener(...arguments_: never[]): unknown` - `close?(...arguments_: never[]): unknown` - `postMessage(...arguments_: never[]): unknown` - `removeEventListener(...arguments_: never[]): unknown` - `start?(...arguments_: never[]): unknown` ### BuilderStateTuple Kind: type; canonical: https://threejs-blocks.com/docs/api/BuilderStateTuple. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { BuilderStateTuple } from "three-blocks/shaders"; type BuilderStateTuple = readonly [vertexShader: string | null, fragmentShader: string | null, computeShader: string | null, attributes: readonly unknown[], bindings: readonly ShaderBindingGroupLike[], updateNodes: readonly ShaderNodeLike[], updateBeforeNodes: readonly ShaderNodeLike[], updateAfterNodes: readonly ShaderNodeLike[], observer: unknown, hardwareClipping: boolean, transforms: readonly unknown[]] ``` **Purpose:** Tuple consumed by the r185 provider hook installed by `three-blocks/vite`. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BuilderStateTuple. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### BuiltinTextFontSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/BuiltinTextFontSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { BuiltinTextFontSource } from "three-blocks/text"; interface BuiltinTextFontSource ``` **Purpose:** Declares BuiltinTextFontSource as a public interface. It is exported from three-blocks/text. Its declared surface covers builtin. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for BuiltinTextFontSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly builtin: string` ### CloneValue Kind: type; canonical: https://threejs-blocks.com/docs/api/CloneValue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { CloneValue } from "three-blocks/worker"; type CloneValue = (value: unknown) => unknown ``` **Purpose:** Declares CloneValue as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for CloneValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ComponentHotOperationContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComponentHotOperationContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ComponentHotOperationContext } from "three-blocks/hmr"; interface ComponentHotOperationContext ``` **Purpose:** Declares ComponentHotOperationContext as a public interface. It is exported from three-blocks/hmr. Its declared surface covers context, key, and options. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComponentHotOperationContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly context: unknown` - `readonly key: string` - `readonly options: unknown` ### ComponentHotRegistry Kind: class; canonical: https://threejs-blocks.com/docs/api/ComponentHotRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ComponentHotRegistry } from "three-blocks/hmr"; class ComponentHotRegistry ``` **Purpose:** Transactional registry used by component-level `import.meta.hot.accept()` handlers. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, mount, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(options?: ComponentHotRegistryOptions)` - `dispose(key: string): Promise` - `disposeAll(): Promise` - `get(key: string): Object3D | undefined` - `has(key: string): boolean` - `mount>(request: ComponentMountRequest): Promise` - `replace>(key: string, Component: ThreeComponentClass): Promise>` ### ComponentHotRegistryOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComponentHotRegistryOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ComponentHotRegistryOptions } from "three-blocks/hmr"; interface ComponentHotRegistryOptions ``` **Purpose:** Declares ComponentHotRegistryOptions as a public interface. It is exported from three-blocks/hmr. Its declared surface covers compile, pause, prepare, and resume. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComponentHotRegistryOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly compile?: (component: Object3D, operation: ComponentHotOperationContext) => MaybePromise`: Compile candidate pipelines before the parent/registry transaction commits. - `readonly pause?: () => void` - `readonly prepare?: (component: Object3D, operation: ComponentHotOperationContext) => MaybePromise`: Await newly required resources while the previous component remains mounted. - `readonly resume?: () => void` ### ComponentHotSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComponentHotSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ComponentHotSnapshot } from "three-blocks/hmr"; interface ComponentHotSnapshot ``` **Purpose:** State intentionally preserved automatically during component replacement. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComponentHotSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly layers: number` - `readonly name: string` - `readonly position: readonly [number, number, number]` - `readonly quaternion: readonly [number, number, number, number]` - `readonly renderOrder: number` - `readonly scale: readonly [number, number, number]` - `readonly visible: boolean` ### ComponentMountRequest Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComponentMountRequest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ComponentMountRequest } from "three-blocks/hmr"; interface ComponentMountRequest> ``` **Purpose:** Declares ComponentMountRequest as a public interface. It is exported from three-blocks/hmr. Its declared surface covers Component, context, index, key, and options, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComponentMountRequest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly Component: ThreeComponentClass` - `readonly context: TContext` - `readonly index?: number` - `readonly key: string` - `readonly options: TOptions` - `readonly parent: Object3D` ### ComponentReplacementResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComponentReplacementResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ComponentReplacementResult } from "three-blocks/hmr"; interface ComponentReplacementResult ``` **Purpose:** Declares ComponentReplacementResult as a public interface. It is exported from three-blocks/hmr. Its declared surface covers cleanupError, current, and previous. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComponentReplacementResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cleanupError?: unknown` - `readonly current: TComponent` - `readonly previous: Object3D` ### ComputeBVHSampler Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeBVHSampler. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeBVHSampler } from "three-blocks"; import { ComputeBVHSampler } from "three-blocks/surface-sampling"; const ComputeBVHSampler: BVHSamplerConstructor ``` **Purpose:** Stable facade for rejection-sampling an SDF volume into GPU positions and instance transforms. Construction requires a ComputeBVHSamplerSource with a generated SDF texture, WebGPU renderer, and usable output capacity; missing SDF resources make kernel construction fail. The source and renderer remain caller-owned, while the sampler creates its output attributes. Call ComputeBVHSampler.compute after SDF or transform updates and before rendering output consumers. The current engine leaves output-attribute backend cleanup to their renderer and garbage-collection lifecycle; detach every consumer before dropping the sampler. Runtime-identical constructor for the narrow SDF-volume sampler facade. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `calculateValidRate(positions: Float32Array): number`: Calculate the percentage of non-zero samples in a CPU position snapshot. - `compute(options?: ComputeBVHSamplerComputeOptions): void`: Submit volume sampling after SDF updates and before dependent rendering. - `new (sdfGenerator: ComputeBVHSamplerSource, renderer: Renderer, count: number, options?: ComputeBVHSamplerOptions): ComputeBVHSampler`: Construct a stable SDF-volume sampler from a caller-owned source and renderer. - `dispose(): void`: End supported use after outputs are detached; this call is currently idempotent. - `readonly output: StorageInstancedBufferAttribute`: Sampler-owned GPU instance matrices from the most recent dispatch. - `readonly positionsBuffer: StorageInstancedBufferAttribute`: Sampler-owned GPU positions from the most recent dispatch. - `readback(): Promise`: Copy current instance matrices into a caller-owned CPU snapshot. - `readbackPositions(): Promise`: Copy current positions into a caller-owned CPU snapshot. - `updateSDF(sdfGenerator: ComputeBVHSamplerSource): void`: Replace the caller-owned SDF source and rebuild the kernel when its texture changes. ### ComputeBVHSamplerComputeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeBVHSamplerComputeOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeBVHSamplerComputeOptions } from "three-blocks/surface-sampling"; interface ComputeBVHSamplerComputeOptions ``` **Purpose:** Per-dispatch choices for SDF-volume rejection sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeBVHSamplerComputeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `debug?: boolean | undefined`: Log sampling bounds and threshold diagnostics for this dispatch. - `sdfThreshold?: number | undefined`: Override the signed-distance threshold for this and later dispatches. ### ComputeBVHSamplerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeBVHSamplerOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeBVHSamplerOptions } from "three-blocks/surface-sampling"; interface ComputeBVHSamplerOptions ``` **Purpose:** Construction choices for SDF-volume rejection sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeBVHSamplerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `alignToNormal?: boolean | undefined`: Whether accepted transforms should align to the SDF gradient. - `maxAttempts?: number | undefined`: Maximum rejection attempts for each output sample. - `scale?: Vector3 | undefined`: Scale written into each accepted instance transform. - `sdfThreshold?: number | undefined`: Signed-distance acceptance threshold. - `seed?: number | undefined`: Seed used to produce a repeatable distribution. - `strategy?: ComputeBVHSamplerStrategy | undefined`: Sampling distribution. Unsupported strategies may yield no accepted samples. - `surfaceWeight?: number | undefined`: Relative surface weighting for surface-biased sampling. ### ComputeBVHSamplerSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeBVHSamplerSource. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeBVHSamplerSource } from "three-blocks/surface-sampling"; interface ComputeBVHSamplerSource ``` **Purpose:** Complete caller-owned SDF state consumed by ComputeBVHSampler. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeBVHSamplerSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `readonly boundsMatrix: Matrix4`: Local normalized-volume coordinates transformed into source-local space. - `readonly geometryBounds: Box3`: Tight source-local geometry bounds used to focus rejection sampling. - `readonly inverseBoundsMatrix: Matrix4`: Source-local coordinates transformed into normalized-volume space. - `readonly meshMatrixWorld: Matrix4`: Source-local coordinates transformed into world space. - `readonly resolution: number`: Cubic voxel dimension used to calculate texture coordinates. - `readonly sdfTexture: Storage3DTexture | null`: Generated volume texture; construction fails while it is unavailable. ### ComputeBVHSamplerStrategy Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeBVHSamplerStrategy. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeBVHSamplerStrategy } from "three-blocks/surface-sampling"; type ComputeBVHSamplerStrategy = 'uniform' | 'surface' | 'custom' ``` **Purpose:** Distribution strategy accepted by SDF-volume sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeBVHSamplerStrategy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. ### ComputeBitonicSort Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeBitonicSort. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ComputeBitonicSort } from "three-blocks/experimental/compute-foundations"; const ComputeBitonicSort: ComputeBitonicSortConstructor ``` **Purpose:** Deterministic GPU bitonic-sort facade for `(key, stableId)` uint pairs. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. - `readonly ascending: boolean`: Whether results are ordered from smallest to largest. - `compute(renderer: THREE.Renderer): void`: Execute every stage and leave the result in caller-owned input storage. - `computeStep(renderer: THREE.Renderer): void`: Execute one stage and automatically wrap after a complete sort. - `new (data: ComputeFoundationStorage<'uvec2'>, options?: ComputeBitonicSortOptions): ComputeBitonicSort`: Construct a sorter over caller-owned `uvec2` key/id storage. - `readonly count: number`: Number of `(key, stableId)` pairs configured at construction. - `dispose(): void`: Release owned scratch resources without disposing caller-owned input. - `init(renderer: THREE.Renderer): void`: Build renderer-specific sort resources without submitting work. - `readonly initialized: boolean`: Whether the renderer-specific graph has been initialized. - `readonly stepCount: number`: Ordered dispatch count required for one complete sort. - `readonly workgroupSize: number`: Workgroup width selected for the active renderer. ### ComputeBitonicSortOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeBitonicSortOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ComputeBitonicSortOptions } from "three-blocks/experimental/compute-foundations"; interface ComputeBitonicSortOptions ``` **Purpose:** Configuration for ComputeBitonicSort. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeBitonicSortOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. - `ascending?: boolean | undefined`: Sort ascending when true or descending when false. - `globalOnly?: boolean | undefined`: Disable shared-memory stages and use only global-memory passes. - `workgroupSize?: number | undefined`: Requested power-of-two workgroup width. ### ComputeFoundationStorage Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeFoundationStorage. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ComputeFoundationStorage } from "three-blocks/experimental/compute-foundations"; type ComputeFoundationStorage = THREE.StorageBufferNode ``` **Purpose:** Caller-owned Three.js storage input consumed in place by a compute foundation. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeFoundationStorage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. ### ComputeFoundationValueType Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeFoundationValueType. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ComputeFoundationValueType } from "three-blocks/experimental/compute-foundations"; type ComputeFoundationValueType = 'float' | 'int' | 'uint' | 'vec2' | 'ivec2' | 'uvec2' | 'vec3' | 'ivec3' | 'uvec3' | 'vec4' | 'ivec4' | 'uvec4' ``` **Purpose:** Scalar and vector element types accepted by compute-foundation storage inputs. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeFoundationValueType. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. ### ComputeInstanceCulling Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCulling. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeInstanceCulling } from "three-blocks"; import { ComputeInstanceCulling } from "three-blocks/instance-culling"; const ComputeInstanceCulling: InstanceCullingConstructor ``` **Purpose:** Stable GPU frustum-culling facade for a Three.js mesh or standalone instance source. Construction requires WebGPU and at least one matrix or position source; inconsistent counts, missing renderer support, or unusable geometry throw before the culler is ready. The culler owns its compacted-ID, indirect, sorting, and optional bounds buffers but never owns the source mesh, geometry, camera, or renderer. Mesh construction installs automatic pre-render updates; standalone use must call ComputeInstanceCulling.setCameraUniforms after camera controls and ComputeInstanceCulling.update before rendering. Readback methods allocate caller-owned diagnostic snapshots. Call ComputeInstanceCulling.dispose when the culler is detached; do not use the instance afterward. Runtime-identical constructor for the narrow stable instance-culling facade. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `attachGeometry(geometry: BufferGeometry): void`: Bind the culler-owned indirect draw command to caller-owned geometry. - `attachMesh(mesh: Mesh): void`: Retain a caller-owned mesh reference for material-aware sorting and cleanup. - `new (mesh: Mesh, renderer: Renderer, options?: ComputeInstanceCullingMeshOptions): ComputeInstanceCulling`: Construct a culler bound to a caller-owned mesh and renderer. - `new (options: ComputeInstanceCullingOptions): ComputeInstanceCulling`: Construct a standalone culler from explicit renderer and storage inputs. - `dispose(): void`: Release culler-owned GPU resources and remove installed mesh hooks. - `getBoundingSphereAt(instanceIndex: number, target?: Vector4): ComputeInstanceCullingBoundingSphereResult | null`: Read one local-space bound without exposing the underlying storage buffer. - `initBoundingSpheresStorage(data?: Float32Array): void`: Allocate or replace culler-owned vec4 storage for per-instance bounds. - `readonly isComputeInstanceCulling: true`: Runtime type guard for the stable culling facade. - `readIndirectArgs(): Promise`: Copy the five indirect draw arguments into a caller-owned diagnostic snapshot. - `readSurvivorIndicesAsync(): Promise`: Copy surviving source IDs into a caller-owned diagnostic snapshot. - `setBoundingSphereAt(instanceIndex: number, center: {readonly x: number; readonly y: number; readonly z: number;}, radius: number): void`: Update one local-space bound when per-instance bounds are enabled. - `setCameraUniforms(camera: Camera): void`: Copy camera matrices after controls update and before the culling dispatch. - `setMaxBoundingSphere(boundsData: ComputeInstanceCullingBoundsData): void`: Derive one conservative shared bound from per-instance sphere data. - `update(): void`: Submit culling after camera/source updates and before rendering the target geometry. ### ComputeInstanceCullingBoundingSphere Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingBoundingSphere. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingBoundingSphere } from "three-blocks/instance-culling"; interface ComputeInstanceCullingBoundingSphere ``` **Purpose:** Local-space sphere accepted by instance-culling configuration. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingBoundingSphere. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. - `readonly center: {readonly x: number; readonly y: number; readonly z: number;}`: Local-space center. - `readonly radius: number`: Non-negative local-space radius. ### ComputeInstanceCullingBoundingSphereResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingBoundingSphereResult. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingBoundingSphereResult } from "three-blocks/instance-culling"; interface ComputeInstanceCullingBoundingSphereResult ``` **Purpose:** Read-only CPU snapshot returned for one configured instance bound. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingBoundingSphereResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. - `readonly center: {readonly x: number | undefined; readonly y: number | undefined; readonly z: number | undefined;}`: Copied local-space center components. - `readonly radius: number | undefined`: Copied radius. ### ComputeInstanceCullingBoundsData Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingBoundsData. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingBoundsData } from "three-blocks/instance-culling"; type ComputeInstanceCullingBoundsData = TypedArray | readonly ComputeInstanceCullingBoundingSphere[] ``` **Purpose:** CPU sphere data accepted when deriving a shared conservative bound. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingBoundsData. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### ComputeInstanceCullingBufferSource Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingBufferSource. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingBufferSource } from "three-blocks/instance-culling"; type ComputeInstanceCullingBufferSource = BufferAttribute | ComputeInstanceCullingStorageAttribute | TypedArray ``` **Purpose:** CPU or GPU attribute data accepted as a culling source. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingBufferSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### ComputeInstanceCullingCommonOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingCommonOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingCommonOptions } from "three-blocks/instance-culling"; interface ComputeInstanceCullingCommonOptions ``` **Purpose:** Configuration shared by mesh-bound and standalone cullers. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingCommonOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. - `boundingSphere?: ComputeInstanceCullingBoundingSphere | Sphere | null | undefined`: Shared local-space bound used for conservative visibility testing. - `boundingSpheresStorage?: ComputeInstanceCullingBufferSource | null | undefined`: Optional caller-provided vec4 sphere storage. - `count?: number | undefined`: Number of source instances. - `enabled?: boolean | undefined`: Whether frustum and LOD rejection is enabled initially. - `forceSort?: boolean | undefined`: Force sorting even when the attached material does not request it. - `frustumPadXY?: number | undefined`: Normalized horizontal and vertical frustum padding. - `frustumPadZFar?: number | undefined`: Far-plane frustum padding. - `frustumPadZNear?: number | undefined`: Near-plane frustum padding. - `indexCount?: number | undefined`: Index count written into the indirect draw command. - `instanceMatrixStorage?: ComputeInstanceCullingBufferSource | null | undefined`: Instance matrices or storage used as the primary culling source. - `perInstanceBoundingBox?: boolean | undefined`: Allocate and test a separate bounding sphere for every instance. - `refNormal?: ComputeInstanceCullingBufferSource | null | undefined`: Optional normals associated with reference positions. - `refPosition?: ComputeInstanceCullingBufferSource | null | undefined`: Positions used when complete matrices are not available. - `sortObjects?: boolean | undefined`: Whether translucent survivors may be depth-sorted. ### ComputeInstanceCullingMeshOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingMeshOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingMeshOptions } from "three-blocks/instance-culling"; interface ComputeInstanceCullingMeshOptions extends ComputeInstanceCullingCommonOptions ``` **Purpose:** Optional overrides for the `(mesh, renderer, options)` constructor. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingMeshOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. - `useInstanceMatrix?: boolean | undefined`: Use the mesh instance-matrix attribute as the culling source. ### ComputeInstanceCullingOptions Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingOptions } from "three-blocks/instance-culling"; type ComputeInstanceCullingOptions = ComputeInstanceCullingStandaloneOptions & ({instanceMatrixStorage: ComputeInstanceCullingBufferSource; refPosition?: ComputeInstanceCullingBufferSource | null | undefined;} | {refPosition: ComputeInstanceCullingBufferSource; instanceMatrixStorage?: ComputeInstanceCullingBufferSource | null | undefined;}) ``` **Purpose:** Standalone configuration requiring a matrix or position source. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### ComputeInstanceCullingStandaloneOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingStandaloneOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingStandaloneOptions } from "three-blocks/instance-culling"; interface ComputeInstanceCullingStandaloneOptions extends ComputeInstanceCullingCommonOptions ``` **Purpose:** Base configuration for a standalone culler. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingStandaloneOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. - `renderer: Renderer`: WebGPU renderer that submits culling and releases associated resources. ### ComputeInstanceCullingStorageAttribute Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeInstanceCullingStorageAttribute. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeInstanceCullingStorageAttribute } from "three-blocks/instance-culling"; type ComputeInstanceCullingStorageAttribute = StorageBufferAttribute | StorageInstancedBufferAttribute ``` **Purpose:** GPU storage attributes accepted as culling inputs. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeInstanceCullingStorageAttribute. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### ComputeMeshDynamicSurfaceSampler Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeMeshDynamicSurfaceSampler. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeMeshDynamicSurfaceSampler } from "three-blocks"; import { ComputeMeshDynamicSurfaceSampler } from "three-blocks/surface-sampling"; const ComputeMeshDynamicSurfaceSampler: DynamicSurfaceSamplerConstructor ``` **Purpose:** Stable facade for continuously sampling a deforming mesh near a world-space region. Construction requires a WebGPU renderer, a positive sample count, and a triangle position attribute; invalid inputs throw before usable outputs are exposed. The sampler owns its compute nodes and output storage, while the source mesh and renderer remain caller-owned. Set the region and source matrix after animation updates, call ComputeMeshDynamicSurfaceSampler.compute, then render consumers of ComputeMeshDynamicSurfaceSampler.outputs. Call ComputeMeshDynamicSurfaceSampler.dispose when finished; disposal is safe to repeat, but using the sampler afterward is an error. Runtime-identical constructor for the narrow dynamic-sampler facade. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `compute(options?: ComputeMeshDynamicSurfaceSamplerComputeOptions): void`: Submit sampling after geometry, animation, region, and matrix updates and before rendering consumers of the output buffers. - `new (mesh: Mesh, attributeName: string | undefined, options: ComputeMeshDynamicSurfaceSamplerOptions): ComputeMeshDynamicSurfaceSampler`: Construct a stable dynamic-mesh sampler and allocate its sampler-owned outputs. - `dispose(): void`: Release compute nodes and sampler-owned GPU storage; safe to call repeatedly. - `markGeometryDirty(): this`: Schedule uploaded CPU geometry changes for the next compute dispatch. - `readonly outputs: ComputeMeshDynamicSurfaceSamplerOutputs`: Sampler-owned GPU outputs; consumers may bind but must not dispose them. - `readSurvivorCountAsync(): Promise`: Read the most recently tracked survivor count as an immutable scalar snapshot. - `readback(): Promise`: Copy positions and normals into caller-owned CPU diagnostic snapshots. - `rebuildFaceDataAsync(): Promise`: Immediately rebuild cached face data after source positions change. - `setCenter(x: number, y: number, z: number): this`: Set the world-space center of the region considered for sampling. - `setDynamicGeometry(enabled?: boolean): this`: Rebuild face data on every dispatch when the source geometry changes on GPU. - `setObjectMatrix(matrix: Matrix4): this`: Copy the source mesh world matrix used by the next compute dispatch. - `setRadius(radius: number): this`: Set the non-negative world-space sampling radius. - `setTrackSurvivors(enabled?: boolean): this`: Enable the survivor counter only while the diagnostic count is needed. ### ComputeMeshDynamicSurfaceSamplerComputeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshDynamicSurfaceSamplerComputeOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshDynamicSurfaceSamplerComputeOptions } from "three-blocks/surface-sampling"; interface ComputeMeshDynamicSurfaceSamplerComputeOptions ``` **Purpose:** Per-dispatch choices for dynamic surface sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshDynamicSurfaceSamplerComputeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `resampleIndex?: number | undefined`: Update only this output index; omit to update the complete output. ### ComputeMeshDynamicSurfaceSamplerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshDynamicSurfaceSamplerOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshDynamicSurfaceSamplerOptions } from "three-blocks/surface-sampling"; interface ComputeMeshDynamicSurfaceSamplerOptions ``` **Purpose:** Required capacity and distribution choices for dynamic surface sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshDynamicSurfaceSamplerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `count: number`: Maximum number of output samples. Must be a positive integer. - `renderer: Renderer`: WebGPU renderer used for compute submission and resource disposal. - `seed?: number | undefined`: Seed used to produce a repeatable distribution. - `useVertexNormals?: boolean | undefined`: Whether interpolated vertex normals should orient generated matrices. ### ComputeMeshDynamicSurfaceSamplerOutputs Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshDynamicSurfaceSamplerOutputs. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshDynamicSurfaceSamplerOutputs } from "three-blocks/surface-sampling"; interface ComputeMeshDynamicSurfaceSamplerOutputs ``` **Purpose:** Sampler-owned GPU outputs produced by dynamic surface sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshDynamicSurfaceSamplerOutputs. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `readonly matrix: StorageInstancedBufferAttribute`: Sampled instance transforms. - `readonly normal: StorageBufferAttribute`: Sampled world-space normals. - `readonly position: StorageBufferAttribute`: Sampled world-space positions. ### ComputeMeshDynamicSurfaceSamplerReadback Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshDynamicSurfaceSamplerReadback. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshDynamicSurfaceSamplerReadback } from "three-blocks/surface-sampling"; interface ComputeMeshDynamicSurfaceSamplerReadback ``` **Purpose:** Caller-owned CPU snapshot returned by dynamic sampler readback. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshDynamicSurfaceSamplerReadback. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `readonly normals: Float32Array`: Caller-owned snapshot of sampled normals. - `readonly positions: Float32Array`: Caller-owned snapshot of sampled positions. ### ComputeMeshSurfaceSampler Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeMeshSurfaceSampler. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeMeshSurfaceSampler } from "three-blocks"; import { ComputeMeshSurfaceSampler } from "three-blocks/surface-sampling"; const ComputeMeshSurfaceSampler: MeshSurfaceSamplerConstructor ``` **Purpose:** Stable facade for sampling a static or skinned mesh surface into GPU instance transforms. Construction validates the source geometry and allocates the sampler-owned compute pipeline and output buffers; malformed triangle data, missing skinning attributes, or an unusable renderer cause construction or dispatch to throw. Call ComputeMeshSurfaceSampler.compute after pose updates and before rendering consumers of ComputeMeshSurfaceSampler.output. The output attributes remain owned by the sampler and must not be disposed independently. Call ComputeMeshSurfaceSampler.dispose once the output is no longer rendered; disposal is safe to repeat. Runtime-identical constructor for the narrow stable surface-sampler facade. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. - `compute(options?: ComputeMeshSurfaceSamplerComputeOptions): Promise`: Submit surface sampling after source pose changes and before rendering any object that consumes the output. A resolved timestamp is returned only when `trackTimestamp` is enabled. - `new (mesh: Mesh, renderer: Renderer, count: number, options?: ComputeMeshSurfaceSamplerOptions): ComputeMeshSurfaceSampler`: Construct a stable static-mesh sampler with caller-owned mesh and renderer inputs. - `dispose(): void`: Release the compute pipeline and every GPU buffer owned by this sampler. - `readonly output: StorageInstancedBufferAttribute`: GPU instance matrices generated by the most recent compute dispatch. - `readonly outputNormal: StorageBufferAttribute | null`: World-space sampled normals, or `null` when normal output was not requested. - `readback(): Promise>`: Copy the current matrices from GPU storage into a caller-owned CPU snapshot. ### ComputeMeshSurfaceSamplerComputeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshSurfaceSamplerComputeOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshSurfaceSamplerComputeOptions } from "three-blocks/surface-sampling"; interface ComputeMeshSurfaceSamplerComputeOptions ``` **Purpose:** Per-dispatch choices for static-mesh surface sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshSurfaceSamplerComputeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `resampleIndex?: number | undefined`: Recompute only this sample index; omit to recompute the complete output. - `trackTimestamp?: boolean | undefined`: Resolve and return a WebGPU compute timestamp for this dispatch. ### ComputeMeshSurfaceSamplerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputeMeshSurfaceSamplerOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ComputeMeshSurfaceSamplerOptions } from "three-blocks/surface-sampling"; interface ComputeMeshSurfaceSamplerOptions ``` **Purpose:** Construction choices for repeatable static-mesh surface sampling. **Status:** Stable through the curated Surface Sampling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeMeshSurfaceSamplerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/surface-sampling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/surface-sampling Direct example imports: none recorded. - `seed?: number | undefined`: Seed used to produce a repeatable distribution. - `useVertexNormals?: boolean | undefined`: Whether interpolated vertex normals should orient the generated matrices. ### ComputeMipAwareBlueNoise Kind: class; canonical: https://threejs-blocks.com/docs/api/ComputeMipAwareBlueNoise. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ComputeMipAwareBlueNoise } from "three-blocks/experimental/core-tsl-effects"; class ComputeMipAwareBlueNoise ``` **Purpose:** Generates a mip-aware blue noise texture using the Hilbert R1 blue noise algorithm. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and init. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/experimental/core-tsl-effects entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(width?: number, height?: number, mipScaleExponent?: number)`: Create a new mip-aware blue noise generator. - `getTexture(): THREE.StorageTexture | null`: Returns the generated blue noise texture. - `height: number` - `init(renderer: THREE.WebGPURenderer): THREE.StorageTexture`: Initializes and generates the blue noise texture using compute shaders. This method must be called before using the texture. - `mipScaleExponent: number` - `storageTexture: THREE.StorageTexture | null` - `width: number` ### ComputePointsSDFGenerator Kind: class; canonical: https://threejs-blocks.com/docs/api/ComputePointsSDFGenerator. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputePointsSDFGenerator } from "three-blocks/sdf-raymarching"; class ComputePointsSDFGenerator ``` **Purpose:** GPU-accelerated SDF (Signed Distance Field) generator for point clouds using PointsBVH. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_points_bvh_volume. - `get bounds(): Box3`: Gets the computed bounding box (includes margin). - `get boundsMatrix(): Matrix4`: Gets the bounds transformation matrix (local to world). - `constructor(options?: ComputePointsSDFGeneratorOptions)`: Create a new point cloud SDF generator. - `customBounds: Box3 | null`: Optional caller-provided world-space SDF bounds. - `dispose(): void`: Disposes GPU resources. - `fillInterior: boolean`: Whether enclosed regions are flood-filled into a signed solid. - `generate(geometry: BufferGeometry, bvh: PointsBVH, renderer: Renderer): Promise`: Generates SDF texture from point cloud geometry and PointsBVH. - `get geometryBounds(): Box3`: Gets the tight geometry bounding box (without margin). - `get inverseBoundsMatrix(): Matrix4`: Gets the inverse bounds matrix (world to local). - `margin: number`: Fractional padding added around the source point bounds. - `resolution: number`: Cubic voxel resolution of the generated SDF texture. - `get sdfTexture(): Storage3DTexture | null`: Gets the generated SDF texture. - `get shellRadius(): number`: Gets the computed shell radius. Sets the shell radius (triggers regeneration on next generate call). - `set shellRadius(value: PointsSDFShellRadius)`: Gets the computed shell radius. Sets the shell radius (triggers regeneration on next generate call). - `shellRadiusOption: PointsSDFShellRadius`: Requested point-shell radius, or automatic density-based selection. - `shellVoxels: number`: Minimum automatic shell thickness measured in voxels. - `threshold: number`: Signed-distance bias applied to generated samples. - `update(geometry: BufferGeometry, bvh: PointsBVH, renderer: Renderer): Promise`: Updates SDF texture with potentially modified point cloud/BVH. More efficient than full regeneration if structure hasn't changed. - `workgroupSize: Vector3`: Compute workgroup dimensions used by the generation kernels. ### ComputePrefixSum Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputePrefixSum. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ComputePrefixSum } from "three-blocks/experimental/compute-foundations"; const ComputePrefixSum: ComputePrefixSumConstructor ``` **Purpose:** In-place exclusive uint prefix-sum facade. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. - `compute(renderer: THREE.Renderer): void`: Compute the complete exclusive prefix sum into the caller-owned input. - `new (data: ComputeFoundationStorage<'uint'>, options?: ComputePrefixSumOptions): ComputePrefixSum`: Construct an exclusive scan over caller-owned uint storage. - `readonly count: number`: Number of live uint elements scanned in place. - `dispose(): void`: Release owned recursive and scratch resources without disposing the input. - `readonly hierarchyDepth: number`: Number of recursive scan levels. - `init(renderer: THREE.Renderer): void`: Build renderer-specific scan resources without submitting work. - `readonly initialized: boolean`: Whether the renderer-specific graph has been initialized. - `readonly maxCount: number`: Maximum element count supported by the compiled recursive topology. - `readonly workgroupSize: number`: Workgroup width selected for the scan. ### ComputePrefixSumOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ComputePrefixSumOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ComputePrefixSumOptions } from "three-blocks/experimental/compute-foundations"; interface ComputePrefixSumOptions ``` **Purpose:** Configuration for ComputePrefixSum. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputePrefixSumOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. - `maxCount?: number | undefined`: Largest replay-time element count supported by the compiled pass topology. - `workgroupSize?: number | undefined`: Power-of-two workgroup width used by the Blelloch scan. ### ComputeRadixSort Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeRadixSort. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ComputeRadixSort } from "three-blocks/experimental/compute-foundations"; const ComputeRadixSort: ComputeRadixSortConstructor ``` **Purpose:** Stable GPU radix-sort facade. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, compute, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. - `compute(renderer: THREE.Renderer): void`: Execute every radix pass and leave the result in caller-owned inputs. - `computeStep(renderer: THREE.Renderer, passIndex: number): void`: Execute one numbered radix pass for an amortized sort. - `new (keys: ComputeFoundationStorage<'uint'>, options?: ComputeRadixSortOptions): ComputeRadixSort`: Construct a sorter over caller-owned uint keys and an optional payload. - `readonly count: number`: Number of key elements configured at construction. - `dispose(): void`: Release owned scratch resources without disposing caller-owned inputs. - `init(renderer: THREE.Renderer): void`: Build renderer-specific compute resources without submitting work. - `readonly initialized: boolean`: Whether the renderer-specific graph has been initialized. - `readonly keyBits: number`: Significant key width consumed by the sort. - `readonly passCount: number`: Number of passes required for one complete sort. - `readonly radixBits: 1 | 2 | 4`: Key bits consumed by one radix pass. - `readonly workgroupSize: number`: Workgroup width selected for the compute graph. ### ComputeRadixSortOptions Kind: type; canonical: https://threejs-blocks.com/docs/api/ComputeRadixSortOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ComputeRadixSortOptions } from "three-blocks/experimental/compute-foundations"; type ComputeRadixSortOptions = {/** Optional caller-owned payload storage reordered in lockstep with the keys. */ values?: ComputeFoundationStorage | undefined; /** Requested compute workgroup width. */ workgroupSize?: number | undefined; /** Key bits consumed by one pass; wider passes trade memory for fewer dispatches. */ radixBits?: 1 | 2 | 4 | undefined; /** Significant key width from one through 32 bits. */ keyBits?: number | undefined; /** Direct dispatch over the configured key capacity. */ indirect?: false | undefined; /** Optional caller-owned active-count storage used to clamp direct work. */ countBuffer?: ComputeFoundationStorage<'uint'> | undefined;} | {/** Optional caller-owned payload storage reordered in lockstep with the keys. */ values?: ComputeFoundationStorage | undefined; /** Requested compute workgroup width. */ workgroupSize?: number | undefined; /** Key bits consumed by one pass; wider passes trade memory for fewer dispatches. */ radixBits?: 1 | 2 | 4 | undefined; /** Significant key width from one through 32 bits. */ keyBits?: number | undefined; /** Indirect dispatch limited by `countBuffer`. */ indirect: true; /** Caller-owned atomic active-count storage required by indirect dispatch. */ countBuffer: ComputeFoundationStorage<'uint'>;} ``` **Purpose:** Configuration for ComputeRadixSort. **Status:** Experimental through the curated Compute foundations block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ComputeRadixSortOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/compute-foundations. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/compute-foundations Direct example imports: none recorded. ### ComputeSDFGenerator Kind: variable; canonical: https://threejs-blocks.com/docs/api/ComputeSDFGenerator. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeSDFGenerator } from "three-blocks/sdf-raymarching"; const ComputeSDFGenerator: ComputeSDFGeneratorConstructor ``` **Purpose:** GPU signed-distance-field generator backed by a mesh BVH. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `readonly bounds: THREE.Box3`: Mutable world-space volume bounds including configured padding. - `readonly boundsMatrix: THREE.Matrix4`: Mutable local-to-world transform for the current normalized SDF volume. - `new (options?: SDFGeneratorOptions): ComputeSDFGenerator`: Construct a lazy generator; no GPU resources are allocated until generation. - `dispose(): void`: Dispose the owned texture, BVH bindings, and compute graph; repeated calls are safe. - `generate(geometry: THREE.BufferGeometry, bvh: GeometryBVH, renderer: THREE.Renderer): Promise`: Generate or replace the owned texture and submit its complete compute workload. - `readonly geometryBounds: THREE.Box3`: Mutable tight source-local geometry bounds consumed by stable volume samplers. - `readonly inverseBoundsMatrix: THREE.Matrix4`: Mutable world-to-local inverse of boundsMatrix. - `margin: number`: World-space padding used when bounds are inferred from the geometry. - `readonly meshMatrixWorld: THREE.Matrix4`: Mutable source-local to world transform consumed by stable volume samplers. - `resolution: number`: Cubic voxel dimension used by subsequent generations. - `readonly sdfTexture: SDFTextureOutput | null`: Current generator-owned texture, or `null` before generation and after disposal. - `threshold: number`: Signed-distance bias used by subsequent generations. - `update(geometry: THREE.BufferGeometry, bvh: GeometryBVH, renderer: THREE.Renderer): Promise`: Refresh a generated field after caller-owned geometry or BVH data changes. ### ComputeSphereRasterizer Kind: class; canonical: https://threejs-blocks.com/docs/api/ComputeSphereRasterizer. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { ComputeSphereRasterizer } from "three-blocks/water"; class ComputeSphereRasterizer extends THREE.Mesh ``` **Purpose:** Software sphere rasterizer: a compute-shader particle renderer that draws opaque sphere impostors with zero hardware overdraw. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, resize, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_compute. - `capacity: number`: Allocated particle capacity. - `colors: ComputeSphereRasterizerColorStorageNode | null`: Optional per-particle colour storage. - `constructor(particles: ComputeSphereRasterizerParticleStorageNode, options?: ComputeSphereRasterizerOptions)`: Create a compute sphere rasterizer for a particle storage buffer. - `depthSlices: number`: Per-tile depth slices used for front-to-back early termination. - `dispose(): void`: Dispose GPU buffers, compute pipelines, and the resolve mesh resources. - `entryCount: number | null`: Latest asynchronously read tile-entry count. - `entryMultiplier: number`: Initial tile-entry capacity multiplier. - `isComputeSphereRasterizer: true`: Runtime type guard that is always `true` for this rasterizer. - `largeCount: number | null`: Latest asynchronously read large-particle count. - `maxTilesPerParticle: number`: Tile-overlap threshold for the cooperative large-particle path. - `overflowCount: number | null`: Latest asynchronously read entry-overflow count. - `particleCount: number`: Active particle count rendered by the next update. - `particles: ComputeSphereRasterizerParticleStorageNode`: Particle centre-and-radius storage consumed by the compute graph. - `readbackInterval: number`: Frames between asynchronous counter readbacks. - `resize(renderer: Renderer): boolean`: Resize the active raster grid to the renderer's drawing buffer. Within the current allocation this only updates uniforms and dispatch sizes; growing past it reallocates the buffers and rebuilds the compute graph. - `get stats(): ComputeSphereRasterizerStats`: Renderer statistics for HUDs and tests. - `uniforms: ComputeSphereRasterizerUniforms`: Mutable TSL uniforms shared by rasterizer compute stages. - `update(renderer: Renderer, camera: Camera): boolean`: Run the binning + raster compute batch for the current camera. Call once per frame before rendering the scene that contains this mesh. ### CreateTextBatchOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/CreateTextBatchOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { CreateTextBatchOptions } from "three-blocks/text/worker"; interface CreateTextBatchOptions ``` **Purpose:** Declares CreateTextBatchOptions as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers font, map, maxGlyphCount, maxTextCount, and screenSpace. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for CreateTextBatchOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly font: TextFontMetrics` - `readonly map: TextTexture` - `readonly maxGlyphCount: number` - `readonly maxTextCount: number` - `readonly screenSpace: true` ### CreateThreeAssetAdaptersOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/CreateThreeAssetAdaptersOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { CreateThreeAssetAdaptersOptions } from "three-blocks/assets"; interface CreateThreeAssetAdaptersOptions ``` **Purpose:** Declares CreateThreeAssetAdaptersOptions as a public interface. It is exported from three-blocks/assets. Its declared surface covers codecs, createCurvePlugin, decodeImage, fetch, and loadMeshopt, plus 3 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for CreateThreeAssetAdaptersOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly codecs: ThreeBlocksCodecRuntimeConfig`: Pass `threeBlocksConfig.codecs` from `three-blocks/vite/config`. - `readonly createCurvePlugin?: ThreeAssetCurvePluginFactory | PromiseLike` - `readonly decodeImage?: ThreeAssetImageDecoder`: Decodes encoded image bytes to an ImageBitmap-compatible object. - `readonly fetch?: ThreeAssetFetch` - `readonly loadMeshopt?: () => ThreeBlocksMeshoptDecoder | PromiseLike`: Pass `loadThreeBlocksMeshoptDecoder` or another compatible lazy resolver. - `readonly loadThree?: () => ThreeAssetThreeModule | PromiseLike`: Override the default lazy `three` module import. - `readonly loaders?: ThreeAssetLoaderFactories` - `readonly renderer: unknown`: Initialized WebGPU or worker-owned WebGL renderer used for KTX2 capability detection. ### CreateWorkerRuntimeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/CreateWorkerRuntimeOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { CreateWorkerRuntimeOptions } from "three-blocks/app"; interface CreateWorkerRuntimeOptions ``` **Purpose:** Declares CreateWorkerRuntimeOptions as a public interface. It is exported from three-blocks/app. Its declared surface covers configuration, loadShaderManifest, page, renderer, and scene, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for CreateWorkerRuntimeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly configuration: WorkerRuntimeConfiguration` - `readonly loadShaderManifest: InstallShaderCacheOptions['loadManifest']` - `readonly page: PageLink` - `readonly renderer: object` - `readonly scene: TextRendererOptions['scene']` - `readonly sceneKey: string` - `readonly text?: TextConfiguration` ### CubeTextureAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/CubeTextureAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { CubeTextureAssetDefinition } from "three-blocks/assets"; interface CubeTextureAssetDefinition extends AssetDefinition<'cubeTexture', readonly [string, string, string, string, string, string], never> ``` **Purpose:** Declares CubeTextureAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers colorSpace and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for CubeTextureAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly colorSpace?: string` - `readonly url: readonly [string, string, string, string, string, string]` ### DevtoolsOverlayHandle Kind: type; canonical: https://threejs-blocks.com/docs/api/DevtoolsOverlayHandle. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { DevtoolsOverlayHandle } from "three-blocks/devtools"; type DevtoolsOverlayHandle = ThreeBlocksDevOverlay ``` **Purpose:** Idempotent handle returned by a mounted development overlay. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for DevtoolsOverlayHandle. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### DevtoolsOverlayOptions Kind: type; canonical: https://threejs-blocks.com/docs/api/DevtoolsOverlayOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { DevtoolsOverlayOptions } from "three-blocks/devtools"; type DevtoolsOverlayOptions = ThreeBlocksOverlayOptions ``` **Purpose:** Options for mounting the development overlay in a page-owned application. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for DevtoolsOverlayOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### DevtoolsRegistration Kind: interface; canonical: https://threejs-blocks.com/docs/api/DevtoolsRegistration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { DevtoolsRegistration } from "three-blocks/devtools"; interface DevtoolsRegistration ``` **Purpose:** Declares DevtoolsRegistration as a public interface. It is exported from three-blocks/devtools. Its declared surface covers configureStats, dispose, removeMetric, setMetric, and setStatsPanelMode, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `configureStats(configure: (panel: object) => void | (() => void)): () => void`: Configure the lazily-created stats-gl instance without forcing it to load. - `dispose(): void` - `removeMetric(key: string): void` - `setMetric(key: string, metric: ThreeBlocksDevtoolsMetric): void` - `setStatsPanelMode(mode: Exclude): Promise` - `setStatsPanelVisible(visible: boolean): Promise` - `readonly smoke: ThreeBlocksSmokeState` ### Dispatcher Kind: class; canonical: https://threejs-blocks.com/docs/api/Dispatcher. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { Dispatcher } from "three-blocks/runtime"; class Dispatcher ``` **Purpose:** Typed local dispatcher with retained events and a deterministic frame scheduler. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, pause, and resume. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `clearRetained>(name: TName): void` - `constructor(options?: DispatcherOptions)` - `fixedStep(delta: number, input?: FixedStepInput): Promise`: Advance without consulting wall time. Repeated calls are deterministic. - `invalidateRenderOrder(): void`: Call after changing a registered component's `raf.renderPriority`. - `isRegistered(component: RuntimeComponent): boolean` - `off>(name: TName, handler: EventHandler): void` - `on>(name: TName, handler: EventHandler): () => void` - `pause(): void` - `get paused(): boolean` - `register(component: RuntimeComponent): () => void` - `resetFixedStep(reset?: FixedStepReset): void` - `resume(): void` - `runFrame(input?: FrameInput): Promise`: Run one clock-driven frame. The first frame after construction/resume receives delta 0. - `setContext(values: Partial>): void` - `trigger>(name: TName, payload: TEvents[TName], options?: TriggerOptions): void` - `unregister(component: RuntimeComponent): void` ### DispatcherOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/DispatcherOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { DispatcherOptions } from "three-blocks/runtime"; interface DispatcherOptions ``` **Purpose:** Declares DispatcherOptions as a public interface. It is exported from three-blocks/runtime. Its declared surface covers clock, context, and maxDelta. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for DispatcherOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly clock?: () => number`: Monotonic clock in seconds. Defaults to `Date.now() / 1000`. - `readonly context?: FrameValues`: Shared renderer/scene/input values copied once into the reused lifecycle contexts. - `readonly maxDelta?: number`: Global frame delta cap in seconds. Defaults to 0.1. ### EventHandler Kind: type; canonical: https://threejs-blocks.com/docs/api/EventHandler. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { EventHandler } from "three-blocks/runtime"; type EventHandler = (payload: TPayload) => void ``` **Purpose:** Declares EventHandler as a public type. It is exported from three-blocks/runtime. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for EventHandler. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### EventMethodMap Kind: type; canonical: https://threejs-blocks.com/docs/api/EventMethodMap. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { EventMethodMap } from "three-blocks/runtime"; type EventMethodMap = {[TName in EventName as `on${Capitalize}`]?: (payload: TEvents[TName]) => void;} ``` **Purpose:** Event `pointermove` maps to method `onPointermove`; casing after the first letter is retained. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for EventMethodMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### EventName Kind: type; canonical: https://threejs-blocks.com/docs/api/EventName. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { EventName } from "three-blocks/runtime"; type EventName = Extract ``` **Purpose:** Typed worker-local events and frame lifecycle for Three Blocks applications. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for EventName. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ExrAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/ExrAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ExrAssetDefinition } from "three-blocks/assets"; interface ExrAssetDefinition extends AssetDefinition<'exr', string, never> ``` **Purpose:** Declares ExrAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ExrAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly url: string` ### FilmHDOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/FilmHDOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { FilmHDOptions } from "three-blocks/core-tsl-effects"; interface FilmHDOptions ``` **Purpose:** Optional node inputs controlling the stable cinematic film effect. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FilmHDOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. - `blueNoiseLevelNode?: TSLIntNode | null`: Blue-noise recursion level used by the grain generator. - `grainContrastNode?: TSLFloatNode | null`: Contrast multiplier applied to the generated grain. - `grainResponseNode?: TSLFloatNode | null`: Luminance response controlling how strongly shadows receive grain. - `grainScaleNode?: TSLFloatNode | null`: Spatial grain-density multiplier. - `grainSpeedNode?: TSLFloatNode | null`: Temporal grain-evolution speed. - `intensityNode?: TSLFloatNode | null`: Grain strength, conventionally between zero and one. - `scanlineFrequencyNode?: TSLFloatNode | null`: Scanline frequency in display-space units. - `scanlineIntensityNode?: TSLFloatNode | null`: Blend amount for the optional scanline overlay. - `timeNode?: TSLFloatNode | null`: Optional time input for deterministic or externally controlled animation. - `uvNode?: TSLVec2Node | null`: Optional UV input replacing the default screen-space coordinates. ### FixedStepInput Kind: interface; canonical: https://threejs-blocks.com/docs/api/FixedStepInput. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FixedStepInput } from "three-blocks/runtime"; interface FixedStepInput ``` **Purpose:** Declares FixedStepInput as a public interface. It is exported from three-blocks/runtime. Its declared surface covers context. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FixedStepInput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly context?: Partial>` ### FixedStepReset Kind: interface; canonical: https://threejs-blocks.com/docs/api/FixedStepReset. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FixedStepReset } from "three-blocks/runtime"; interface FixedStepReset ``` **Purpose:** Declares FixedStepReset as a public interface. It is exported from three-blocks/runtime. Its declared surface covers elapsedTime and startTime. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FixedStepReset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly elapsedTime?: number` - `readonly startTime?: number` ### FontAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/FontAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FontAssetDefinition } from "three-blocks/assets"; interface FontAssetDefinition extends AssetDefinition<'font', string, never> ``` **Purpose:** Declares FontAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers family and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FontAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly family?: string` - `readonly url: string` ### FrameContext Kind: type; canonical: https://threejs-blocks.com/docs/api/FrameContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FrameContext } from "three-blocks/runtime"; type FrameContext = Readonly & FrameTiming> ``` **Purpose:** A readonly lifecycle view. One internal object is reused between handlers, so consumers must read it synchronously and must not retain it. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FrameContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### FrameInput Kind: interface; canonical: https://threejs-blocks.com/docs/api/FrameInput. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FrameInput } from "three-blocks/runtime"; interface FrameInput ``` **Purpose:** Declares FrameInput as a public interface. It is exported from three-blocks/runtime. Its declared surface covers context, delta, elapsedTime, now, and startTime. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FrameInput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly context?: Partial>`: Partial updates for shared lifecycle values. - `readonly delta?: number`: Explicit raw delta in seconds. When omitted it is derived from the clock. - `readonly elapsedTime?: number`: Explicit elapsed time in seconds. - `readonly now?: number`: Current monotonic time in seconds. - `readonly startTime?: number`: Explicit lifecycle start time in seconds. ### FrameLifecycle Kind: interface; canonical: https://threejs-blocks.com/docs/api/FrameLifecycle. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FrameLifecycle } from "three-blocks/runtime"; interface FrameLifecycle ``` **Purpose:** Declares FrameLifecycle as a public interface. It is exported from three-blocks/runtime. Its declared surface covers onAfterRaf, onBeforeRaf, onRaf, onThrottle, and raf. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FrameLifecycle. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `onAfterRaf?(context: FrameContext): void | PromiseLike` - `onBeforeRaf?(context: FrameContext): void | PromiseLike` - `onRaf?(context: FrameContext): void | PromiseLike` - `onThrottle?(context: FrameContext): void | PromiseLike` - `readonly raf?: RafOptions` ### FrameTiming Kind: interface; canonical: https://threejs-blocks.com/docs/api/FrameTiming. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { FrameTiming } from "three-blocks/runtime"; interface FrameTiming ``` **Purpose:** Declares FrameTiming as a public interface. It is exported from three-blocks/runtime. Its declared surface covers delta, elapsedTime, startTime, and throttleInterpolation. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for FrameTiming. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly delta: number` - `readonly elapsedTime: number` - `readonly startTime: number` - `readonly throttleInterpolation: number` ### GPUInteractionCapabilityReport Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionCapabilityReport. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionCapabilityReport } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionCapabilityReport ``` **Purpose:** Read-only WebGPU capability and renderer-limit report. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionCapabilityReport. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly available: boolean | null`: Overall availability, or `null` when no renderer was inspected. - `readonly compute: boolean | null`: Whether compute submission is available, or `null` before inspection. - `readonly feedback: false`: Whether two-way feedback reduction is available. - `readonly feedbackReason: string`: Human-readable explanation of the current feedback support level. - `readonly initialized: boolean`: Whether the world has completed initialization. - `readonly reasons: readonly string[]`: Human-readable reasons the configured system is unavailable. - `readonly sharedArrayBuffer: boolean`: Whether the runtime provides `SharedArrayBuffer`. - `readonly smoke: Readonly<{/** Storage format required by smoke interaction. */ requiredStorageFormat: 'rgba16float'; /** Format availability, or `null` when no renderer was inspected. */ storageFormatSupported: boolean | null; /** Human-readable incompatibility reason. */ reason: string | null;}>`: Smoke-volume storage-texture compatibility. - `readonly storage: Readonly<{/** Compatibility, or `null` when no renderer was inspected. */ compatible: boolean | null; /** Minimum renderer limits for the shared interaction storage. */ requiredRendererLimits: GPUInteractionStorageRendererLimits; /** Largest single shared allocation. */ largestBuffer: Readonly<{name: string | null; bytes: number;}>; /** Total shared storage byte estimate. */ totalByteLength: number; /** Renderer limits below the configured requirements. */ failures: readonly GPUInteractionLimitFailure[];}>`: Shared storage compatibility and sizing information. - `readonly webgpu: boolean | null`: Whether the inspected renderer uses WebGPU, or `null` before inspection. ### GPUInteractionGridOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionGridOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionGridOptions } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionGridOptions ``` **Purpose:** Spatial-hash configuration used by a shared interaction world. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionGridOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `cellSize?: number | undefined`: World-space width of one grid cell. - `dimensions?: readonly [number, number, number] | undefined`: Positive integer cell counts on the X, Y, and Z axes. - `maxCellsPerCollider?: number | undefined`: Maximum grid cells linked by one collider before it becomes global. - `origin?: readonly [number, number, number] | undefined`: World-space minimum corner of the grid. ### GPUInteractionLimitFailure Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionLimitFailure. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionLimitFailure } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionLimitFailure ``` **Purpose:** One renderer-limit incompatibility reported before initialization. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionLimitFailure. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly available: number`: Value available on the inspected renderer. - `readonly name: string`: WebGPU limit name. - `readonly required: number`: Minimum value required by the configured interaction world. ### GPUInteractionPhysicsEngine Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionPhysicsEngine. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionPhysicsEngine } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionPhysicsEngine ``` **Purpose:** Physics engine adapter accepted by GPUInteractionSystem.addPhysics. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionPhysicsEngine. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `createInteractionSource(options: Record): TSource`: Create the fixed-capacity collider source owned by the interaction world. ### GPUInteractionPhysicsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionPhysicsOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionPhysicsOptions } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionPhysicsOptions ``` **Purpose:** Physics-source creation options passed through by the system. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionPhysicsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `[option: string]: unknown`: Engine-specific source options forwarded to `createInteractionSource()`. - `step?: GPUInteractionPhysicsStep | undefined`: Scheduler phase, automatic source preference, or manual physics stepping. ### GPUInteractionPhysicsSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionPhysicsSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionPhysicsSource } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionPhysicsSource extends GPUInteractionSource ``` **Purpose:** Collider source optionally capable of advancing its owning physics engine. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionPhysicsSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `advancePhysics?(renderer: THREE.Renderer, deltaTime: number): unknown`: Advance source physics during its selected scheduler phase. - `readonly interactionStepPhase?: 'before' | 'after' | null | undefined`: Preferred automatic physics phase. - `readonly interactionStorageBufferRequirement?: number | undefined`: Storage-buffer binding count required by this source. ### GPUInteractionPhysicsStep Kind: type; canonical: https://threejs-blocks.com/docs/api/GPUInteractionPhysicsStep. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionPhysicsStep } from "three-blocks/experimental/gpu-interaction"; type GPUInteractionPhysicsStep = 'auto' | 'before' | 'after' | 'manual' ``` **Purpose:** Physics stepping policy used by GPUInteractionSystem.addPhysics. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionPhysicsStep. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. ### GPUInteractionQueryMode Kind: type; canonical: https://threejs-blocks.com/docs/api/GPUInteractionQueryMode. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionQueryMode } from "three-blocks/experimental/gpu-interaction"; type GPUInteractionQueryMode = 'grid' | 'scan' ``` **Purpose:** Broadphase query strategy used by an interaction-enabled simulation. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionQueryMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. ### GPUInteractionRequiredRendererLimits Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionRequiredRendererLimits. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionRequiredRendererLimits } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionRequiredRendererLimits extends GPUInteractionStorageRendererLimits ``` **Purpose:** Renderer limits required by a complete interaction system. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionRequiredRendererLimits. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly maxStorageBuffersPerShaderStage: number`: Minimum storage-buffer binding count used by registered simulation passes. ### GPUInteractionSimulation Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSimulation. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSimulation } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSimulation ``` **Purpose:** Simulation lifecycle required by GPUInteractionSystem. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: step. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `clearInteractionWorld?(): void`: Detach the shared world without disposing the simulation. - `setInteractionWorld(world: GPUInteractionWorld, options: GPUInteractionSimulationOptions): unknown`: Attach the shared world before system initialization. - `step(renderer: THREE.Renderer, deltaTime: number): unknown`: Advance one simulation step between world begin-frame and feedback resolution. ### GPUInteractionSimulationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSimulationOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSimulationOptions } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSimulationOptions ``` **Purpose:** Options forwarded when a simulation is attached to the shared world. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionSimulationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `[option: string]: unknown`: Simulation-specific interaction options. - `queryMode?: GPUInteractionQueryMode | undefined`: Spatial-grid broadphase or direct collider scan. ### GPUInteractionSizingReport Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSizingReport. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSizingReport } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSizingReport ``` **Purpose:** Read-only fixed-capacity and storage estimate for an interaction world. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionSizingReport. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly cellArrayBytes: number`: Bytes reserved by cell-offset and cell-cursor arrays. - `readonly cellCount: number`: Total number of spatial-hash cells. - `readonly colliderBytes: number`: Bytes reserved by collider attributes. - `readonly feedbackBytes: number`: Bytes reserved by optional feedback attributes. - `readonly globalColliderBytes: number`: Bytes reserved by the global collider list. - `readonly grid: Readonly`: Grid configuration used to calculate the report. - `readonly linkBytes: number`: Bytes reserved by collider-to-cell links. - `readonly maxColliders: number`: Maximum colliders reserved by the world. - `readonly maxFeedbackColliders: number`: Maximum feedback colliders reserved by the world. - `readonly maxGlobalColliders: number`: Maximum global colliders reserved by the world. - `readonly maxGridLinks: number`: Maximum broadphase grid links reserved by the world. - `readonly totalBytes: number`: Total estimated storage bytes owned by the world. ### GPUInteractionSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSource } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSource ``` **Purpose:** Lifecycle contract for a collider producer. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: initialize, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `afterFeedbackResolved?(renderer: THREE.Renderer): void`: Consume resolved feedback after all registered simulations have stepped. - `attach(world: GPUInteractionWorld, range: GPUInteractionSourceRange): void`: Receive the owning world and immutable collider-slot reservation. - `readonly capacity: number`: Fixed number of collider slots required by the source. - `detach?(): void`: Detach from the world without necessarily releasing source-owned resources. - `dispose?(): void`: Release resources owned by this source. - `initialize?(renderer: THREE.Renderer): unknown`: Allocate source resources after the world has allocated its shared resources. - `update?(renderer: THREE.Renderer, deltaTime: number): number | null | undefined`: Publish current collider transforms before the frame broadphase is built. ### GPUInteractionSourceRange Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSourceRange. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSourceRange } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSourceRange ``` **Purpose:** Immutable collider-slot reservation assigned to one source. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionSourceRange. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly baseColliderSlot: number`: First collider slot owned by the source. - `readonly capacity: number`: Number of consecutive collider slots reserved for the source. ### GPUInteractionStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionStats. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionStats } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionStats ``` **Purpose:** Read-only counters describing shared interaction work and bounded overflows. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly activeColliders: number`: Active colliders published during the latest frame. - `readonly activeFeedbackColliders: number`: Colliders currently configured to receive feedback. - `readonly colliderOverflows: number`: Source collider slots rejected because world capacity was exhausted. - `readonly feedbackColliderOverflows: number`: Feedback colliders dropped beyond configured capacity. - `readonly feedbackContributionOverflows: number`: Feedback contributions dropped beyond configured capacity. - `readonly feedbackContributions: number`: Feedback contributions accepted by the latest reduction. - `readonly globalColliderOverflows: number`: Global colliders dropped beyond configured capacity. - `readonly globalColliders: number`: Oversized or unbounded colliders retained in the global list. - `readonly gridLinkOverflows: number`: Broadphase grid links dropped beyond configured capacity. - `readonly gridLinks: number`: Broadphase grid links retained during the latest readback. - `readonly skippedPackedReadbacks: number`: Packed physics readbacks skipped to avoid overlapping work. - `readonly stalePackedBodies: number`: Packed physics bodies skipped because their data was stale. - `readonly unsupportedShapes: number`: Collider shapes skipped because a consumer does not support them. ### GPUInteractionStorageRendererLimits Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionStorageRendererLimits. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionStorageRendererLimits } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionStorageRendererLimits ``` **Purpose:** Renderer limits required by the world's shared storage allocations. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionStorageRendererLimits. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly maxBufferSize: number`: Minimum allocatable buffer size in bytes. - `readonly maxStorageBufferBindingSize: number`: Minimum storage-buffer binding size in bytes. ### GPUInteractionSystem Kind: variable; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSystem. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { GPUInteractionSystem } from "three-blocks/experimental/gpu-interaction"; const GPUInteractionSystem: GPUInteractionSystemConstructor ``` **Purpose:** Shared physics-to-simulation scheduler. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, initialize, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `addPhysics(physics: GPUInteractionPhysicsEngine, options?: GPUInteractionPhysicsOptions): TSource`: Create, register, and transfer ownership of a physics collider source. - `addSimulation(simulation: TSimulation, options?: GPUInteractionSimulationOptions): TSimulation`: Attach a simulation without transferring ownership of that simulation. - `new (options?: GPUInteractionSystemOptions): GPUInteractionSystem`: Construct an uninitialized scheduler and its owned world. - `dispose(): void`: Detach simulations and dispose the owned world and physics sources. - `readonly disposed: boolean`: Whether this scheduler has released its owned resources. - `getCapabilityReport(renderer?: THREE.Renderer | null): GPUInteractionCapabilityReport`: Inspect WebGPU and configured renderer-limit compatibility. - `getMetrics(): GPUInteractionStats`: Return the current frozen CPU-visible counter snapshot. - `getRequiredRendererLimits(): GPUInteractionRequiredRendererLimits`: Return limits to request when constructing the renderer, before initialization. - `getSizingReport(): GPUInteractionSizingReport`: Return fixed-capacity and estimated-storage diagnostics. - `initialize(renderer: THREE.Renderer): Promise`: Allocate the shared world after all sources and simulations are registered. - `readonly initialized: boolean`: Whether the system and its shared world have initialized. - `removeSimulation(simulation: GPUInteractionSimulation): boolean`: Detach a simulation without disposing it. - `requestMetricsReadback(): Promise`: Explicitly refresh bounded GPU counters; avoid calling every frame. - `step(renderer?: THREE.Renderer | null, deltaTime?: number): Promise`: Execute one non-overlapping interaction frame in the documented order. - `readonly world: GPUInteractionWorld`: Shared world owned and disposed by this scheduler. ### GPUInteractionSystemOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionSystemOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionSystemOptions } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionSystemOptions extends GPUInteractionWorldOptions ``` **Purpose:** Construction options for the shared interaction scheduler. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionSystemOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `world?: GPUInteractionWorld | GPUInteractionWorldOptions | undefined`: Existing world to use, or options for the world owned by the system. ### GPUInteractionWorld Kind: variable; canonical: https://threejs-blocks.com/docs/api/GPUInteractionWorld. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { GPUInteractionWorld } from "three-blocks/experimental/gpu-interaction"; const GPUInteractionWorld: GPUInteractionWorldConstructor ``` **Purpose:** Shared moving-collider world. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, initialize, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `addSource(source: TSource): TSource`: Register and transfer ownership of a fixed-capacity collider source. - `beginFrame(renderer?: THREE.Renderer | null, deltaTime?: number): this`: Publish source transforms and build the broadphase for one frame. - `new (options?: GPUInteractionWorldOptions): GPUInteractionWorld`: Construct an uninitialized world with fixed capacities. - `dispose(): void`: Dispose registered sources and every shared GPU allocation. - `readonly disposed: boolean`: Whether this world has released its owned resources. - `getCapabilityReport(renderer?: THREE.Renderer | null): GPUInteractionCapabilityReport`: Inspect WebGPU and configured renderer-limit compatibility. - `getMetrics(): GPUInteractionStats`: Return the current frozen CPU-visible counter snapshot. - `getSizingReport(): GPUInteractionSizingReport`: Return fixed-capacity and estimated-storage diagnostics. - `initialize(renderer: THREE.Renderer): Promise`: Allocate shared resources and initialize all registered sources. - `readonly initialized: boolean`: Whether shared resources have been allocated. - `removeSource(source: GPUInteractionSource): boolean`: Remove and detach a source before initialization without disposing it. - `requestMetricsReadback(renderer?: THREE.Renderer | null): Promise`: Explicitly refresh bounded GPU counters; avoid calling every frame. - `resetMetrics(): this`: Clear all accumulated counter values. - `resolveFeedback(renderer?: THREE.Renderer | null): this`: Resolve enabled feedback producers and close the current frame. ### GPUInteractionWorldOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GPUInteractionWorldOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { GPUInteractionWorldOptions } from "three-blocks/experimental/gpu-interaction"; interface GPUInteractionWorldOptions ``` **Purpose:** Fixed capacities and broadphase configuration for GPUInteractionWorld. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GPUInteractionWorldOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `grid?: GPUInteractionGridOptions | undefined`: Spatial-hash configuration. - `maxColliders?: number | undefined`: Maximum colliders reserved across every registered source. - `maxFeedbackColliders?: number | undefined`: Maximum colliders that may contribute optional feedback. - `maxGlobalColliders?: number | undefined`: Maximum oversized or unbounded colliders scanned globally. - `maxGridLinks?: number | undefined`: Maximum collider-to-grid-cell links in the broadphase. ### GaussianSplats Kind: variable; canonical: https://threejs-blocks.com/docs/api/GaussianSplats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GaussianSplats } from "three-blocks/gaussian-splats"; const GaussianSplats: GaussianSplatsConstructor ``` **Purpose:** Renderable Gaussian scene facade. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `alphaMode: 'straight' | 'premultiplied'`: Alpha representation used by the default material. - `autoUpdate: boolean`: Whether scene rendering performs the per-frame update automatically. - `new (options?: GaussianSplatsOptions): GaussianSplats`: Construct an empty renderer; call `setData()` before rendering it. - `readonly count: number`: Number of source splats accepted from the most recent data set. - `dispose(): void`: Release owned GPU resources, listeners, and any explicitly owned material. - `enableSH: boolean`: Whether spherical-harmonic color is enabled. - `getRenderRecommendation(renderer: THREE.Renderer, camera: THREE.Camera): GaussianSplatsRenderRecommendation`: Return a resolution recommendation without resizing the renderer. - `invalidate(): this`: Force projection and sorting to run on the next update. - `readonly isGaussianSplats: true`: Runtime type guard. - `readonly material: THREE.Material | null`: Default material, or the application-provided material. - `readonly maxDataSHDegree: number`: Highest spherical-harmonic degree present in the current source. - `readonly maxSplats: number`: Allocated splat capacity. - `maxStdDev: number`: Maximum rendered Gaussian extent in standard deviations. - `readStats(): Promise`: Read current GPU-visible counts and timings; avoid calling every frame. - `readonly renderVersion: number`: Number of completed non-shadow renders. - `setData(data: GaussianSplatsData): void`: Replace the source attributes and upload them. - `shDegree: number`: Active spherical-harmonic degree from zero through the source maximum. - `readonly stats: Readonly`: Cheap CPU-visible diagnostic snapshot without GPU synchronization. - `update(renderer: THREE.Renderer, camera: THREE.Camera): void`: Perform culling, projection, and sorting for one camera. - `readonly visibleCount: number`: CPU-visible draw count, which may trail the GPU until a readback. - `waitForRender(options?: GaussianSplatsWaitOptions): Promise`: Wait for a later non-shadow render or reject on cancellation/disposal. ### GaussianSplatsAppearanceOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsAppearanceOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsAppearanceOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsAppearanceOptions ``` **Purpose:** Intentional appearance controls applied after a splat asset is loaded. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsAppearanceOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `contrast?: number | undefined`: Image contrast adjustment applied by the default material. - `exposure?: number | undefined`: Image exposure adjustment applied by the default material. - `metalness?: number | undefined`: Metalness used when lit rendering is enabled. - `mode?: 'unlit' | 'lit' | undefined`: Whether the splats are unlit or participate in scene lighting. - `opacity?: number | undefined`: Global opacity multiplier in the inclusive range from zero to one. - `roughness?: number | undefined`: Roughness used when lit rendering is enabled. - `saturation?: number | undefined`: Image saturation adjustment applied by the default material. - `vibrance?: number | undefined`: Perceptual saturation adjustment that favors muted colors. ### GaussianSplatsData Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsData. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsData } from "three-blocks/gaussian-splats"; interface GaussianSplatsData ``` **Purpose:** Expanded in-memory attributes accepted by GaussianSplats.setData. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsData. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `colors: Float32Array`: Four linear RGBA floats per splat. - `count: number`: Number of valid splats represented by the attribute arrays. - `normals?: Float32Array | null | undefined`: Optional three-float normals used by lit rendering. - `positions: Float32Array`: Three source-space position floats per splat. - `rotations: Float32Array`: Four quaternion floats per splat. - `scales: Float32Array`: Three log-scale floats per splat. - `shCoefficients?: Float32Array | null | undefined`: Optional flattened spherical-harmonic coefficients. - `shDegree?: number | undefined`: Highest spherical-harmonic degree present in the data. - `sourceFormat?: string | undefined`: Human-readable source format included in diagnostics. ### GaussianSplatsGPUTimings Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsGPUTimings. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsGPUTimings } from "three-blocks/gaussian-splats"; interface GaussianSplatsGPUTimings ``` **Purpose:** Optional GPU timestamp results from the most recently resolved frame. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsGPUTimings. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly available: boolean`: Whether the active renderer provides timestamp results. - `readonly projectionMilliseconds: number | null`: Projection time, or `null` when unavailable. - `readonly sortMilliseconds: number | null`: Sorting time, or `null` when unavailable. - `readonly tilesMilliseconds: number | null`: Compute-tile time, or `null` when that path is inactive or unavailable. - `readonly totalMilliseconds: number | null`: Sum of available stage timings, or `null` when unavailable. - `readonly unpackMilliseconds: number | null`: Video/source unpack compute time, or `null` when that stage is inactive. - `readonly uploadMilliseconds: number | null`: CPU time spent submitting the current frame's source upload, or `null`. ### GaussianSplatsHelper Kind: class; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsHelper. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GaussianSplatsHelper } from "three-blocks/gaussian-splats"; class GaussianSplatsHelper extends THREE.Object3D ``` **Purpose:** Debug helper for visualizing Gaussian Splat bounding boxes. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. - `constructor(splats: GaussianSplatsHelperTarget, options?: GaussianSplatsHelperOptions)`: Create a GaussianSplatsHelper. - `dispose(): void`: Dispose of helper resources. - `readonly isGaussianSplatsHelper: true`: Runtime type guard that is always `true` for this helper. - `static get type(): string`: Stable helper type name. - `update(): void`: Update visualizations when splat data changes. ### GaussianSplatsLoadOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsLoadOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsLoadOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsLoadOptions extends GaussianSplatsLoaderOptions ``` **Purpose:** High-level options for GaussianSplats.load and GaussianSplats.parse. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsLoadOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `appearance?: GaussianSplatsAppearanceOptions | undefined`: Appearance controls applied after the source is uploaded. - `autoUpdate?: boolean | undefined`: Whether scene rendering automatically performs the per-frame update. - `manager?: THREE.LoadingManager | undefined`: Optional Three.js loading manager used by URL loading. - `onProgress?: (event: ProgressEvent) => void`: Receives network transfer progress for URL loading. - `quality?: GaussianSplatsQuality | undefined`: Rendering preset; `auto` currently selects the balanced profile. - `sh?: number | boolean | 'auto' | undefined`: SH degree, `false` to disable SH, or `auto` to use the asset default. ### GaussianSplatsLoadTimings Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsLoadTimings. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsLoadTimings } from "three-blocks/gaussian-splats"; interface GaussianSplatsLoadTimings ``` **Purpose:** Timing snapshot produced while parsing and uploading one source. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsLoadTimings. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `chunkBoundsMilliseconds?: number | undefined`: Hierarchical bounds construction time in milliseconds. - `mortonMilliseconds?: number | undefined`: Morton ordering time in milliseconds. - `parseMilliseconds?: number | undefined`: Total parsing and preprocessing time in milliseconds. - `sanitizeMilliseconds?: number | undefined`: Attribute sanitization time in milliseconds. - `sourceParseMilliseconds?: number | undefined`: Source-format decoding time in milliseconds. - `uploadMilliseconds?: number | undefined`: Initial GPU upload time in milliseconds. - `workerMilliseconds?: number | undefined`: Worker round-trip time in milliseconds when a worker was used. ### GaussianSplatsLoader Kind: variable; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsLoader. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GaussianSplatsLoader } from "three-blocks/gaussian-splats"; const GaussianSplatsLoader: GaussianSplatsLoaderConstructor ``` **Purpose:** Three.js-style loader facade for PLY, SPLAT, SPLATS, and SOG assets. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and load. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `new (manager?: THREE.LoadingManager): GaussianSplatsLoader`: Construct a loader using the supplied Three.js loading manager. - `load(url: string, onLoad?: (splats: GaussianSplats) => void, onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void, options?: GaussianSplatsLoaderOptions): void`: Load a URL and deliver the owned renderable to a callback. - `loadAsync(url: string, onProgress?: (event: ProgressEvent) => void, options?: GaussianSplatsLoaderOptions): Promise`: Load a URL and resolve with an owned renderable. - `parse(buffer: ArrayBuffer, url: string, options?: GaussianSplatsLoaderOptions): GaussianSplats | Promise`: Parse a buffer synchronously except for formats that require image decoding. - `parseAsync(buffer: ArrayBuffer, url: string, options?: GaussianSplatsLoaderOptions): Promise`: Parse a buffer and always resolve asynchronously. ### GaussianSplatsLoaderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsLoaderOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsLoaderOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsLoaderOptions extends GaussianSplatsOptions ``` **Purpose:** Options shared by URL loading and in-memory parsing. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsLoaderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `mortonOrdering?: boolean | undefined`: Whether input rows are Morton ordered before upload. - `onProcessProgress?: (progress: GaussianSplatsProcessingProgress) => void`: Receives deterministic processing-stage progress snapshots. - `signal?: AbortSignal | undefined`: Optional cancellation signal for network and processing work. - `transferSourceBuffer?: boolean | undefined`: Whether worker parsing may detach the caller-owned source buffer. - `worker?: boolean | 'auto' | undefined`: Whether parsing uses a worker, or `auto` to use one only for large inputs. - `workerThreshold?: number | undefined`: Minimum source byte length at which automatic worker parsing begins. ### GaussianSplatsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsOptions ``` **Purpose:** Construction controls for a manually populated GaussianSplats object. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `alphaMode?: 'straight' | 'premultiplied' | undefined`: Alpha representation expected by the default material. - `attributeMode?: 'expanded' | 'compact' | 'sog' | 'auto' | undefined`: Source-attribute storage policy. - `coordinateSystem?: 'threejs' | 'source' | undefined`: Coordinate convention used by the loaded source data. - `enableSH?: boolean | undefined`: Whether spherical-harmonic view-dependent color is enabled. - `frustumCulling?: boolean | undefined`: Whether GPU frustum culling is enabled. - `lightingMode?: 'unlit' | 'lit' | undefined`: Initial lighting behavior of the default material. - `material?: THREE.Material | null | undefined`: Optional application-provided material. - `maxBufferBytes?: number | undefined`: Maximum byte size permitted for one GPU storage allocation. - `maxSplats?: number | undefined`: Maximum number of source splats accepted by the renderer. - `ownsMaterial?: boolean | undefined`: Whether GaussianSplats.dispose also disposes an application-provided material. - `recommendedRenderScale?: number | undefined`: Application-managed render-scale recommendation reported in diagnostics. - `rendererMode?: 'auto' | 'raster' | 'compute-tiles' | undefined`: Preferred renderer path, with `auto` selecting a supported path. - `shDegree?: number | undefined`: Spherical-harmonic degree from zero through three. - `sortAlgorithm?: 'radix' | 'bitonic' | undefined`: GPU sorting strategy. - `sortEnabled?: boolean | undefined`: Whether transparent splats are depth sorted. - `sortMode?: 'radial' | 'depth' | undefined`: Sort-key interpretation used for transparent ordering. - `sortPrecision?: 'float16' | 'float32' | undefined`: Sort-key precision used by the GPU sorter. - `temporalStability?: boolean | undefined`: Whether an unchanged camera may reuse the previous projection and sort. ### GaussianSplatsPoints Kind: class; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsPoints. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GaussianSplatsPoints } from "three-blocks/gaussian-splats"; class GaussianSplatsPoints extends THREE.Points ``` **Purpose:** Visualizes Gaussian Splat positions as a point cloud. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer, https://threejs-blocks.com/examples/webgpu_points_bvh_volume. - `constructor(splats: GaussianSplatsPointsSource, options?: GaussianSplatsPointsOptions)`: Create a GaussianSplatsPoints visualization. - `dispose(): void`: Dispose of resources. - `readonly isGaussianSplatsPoints: true`: Runtime type guard that is always `true` for this point-cloud helper. - `static get type(): 'GaussianSplatsPoints'`: Stable helper type name. - `update(): void`: Update point positions when splat data changes. ### GaussianSplatsProcessingProgress Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsProcessingProgress. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsProcessingProgress } from "three-blocks/gaussian-splats"; interface GaussianSplatsProcessingProgress ``` **Purpose:** Deterministic progress snapshot emitted while a source is processed. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsProcessingProgress. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly loaded: number`: Completed work units for the active stage. - `readonly progress: number`: Normalized progress from zero through one. - `readonly stage: 'source-parse' | 'sanitize' | 'morton-ordering' | 'chunk-bounds' | 'complete'`: Active processing stage. - `readonly total: number`: Total work units for the active stage. - `readonly type: 'processing'`: Progress payload discriminator. ### GaussianSplatsQuality Kind: type; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsQuality. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsQuality } from "three-blocks/gaussian-splats"; type GaussianSplatsQuality = 'auto' | 'quality' | 'balanced' | 'performance' | 'xr' ``` **Purpose:** Outcome-oriented rendering preset used by the asynchronous load helpers. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsQuality. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. ### GaussianSplatsRenderEvent Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsRenderEvent. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsRenderEvent } from "three-blocks/gaussian-splats"; interface GaussianSplatsRenderEvent ``` **Purpose:** Completion payload for a non-shadow Gaussian render. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsRenderEvent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly camera?: THREE.Camera | undefined`: Camera used by the completed render when available. - `readonly renderer?: THREE.Renderer | undefined`: Renderer responsible for the completed render when dispatched by a scene. - `readonly scene?: THREE.Scene | undefined`: Scene responsible for the completed render when available. - `readonly type: 'rendercomplete'`: Event discriminator. - `readonly version: number`: Monotonically increasing completed-render version. ### GaussianSplatsRenderRecommendation Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsRenderRecommendation. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsRenderRecommendation } from "three-blocks/gaussian-splats"; interface GaussianSplatsRenderRecommendation ``` **Purpose:** Application-managed resolution recommendation for the active camera and target. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsRenderRecommendation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly minDimensionCap: number`: Suggested upper bound for the shortest render-target dimension. - `readonly reason: string`: Stable diagnostic reason for the recommendation. - `readonly rendererMode: string`: Renderer path used to make the recommendation. - `readonly scale: number`: Suggested multiplier for the application's render target dimensions. ### GaussianSplatsStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStats } from "three-blocks/gaussian-splats"; interface GaussianSplatsStats ``` **Purpose:** Read-only renderer diagnostic snapshot. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly attributeMode: string | null`: Active source-attribute storage mode. - `readonly compactedSplats: number | null`: Compacted splat count, or `null` until readback. - `readonly drawSplats: number`: Current draw count visible to the CPU. - `readonly gpuBytes: number`: Estimated bytes owned by all Gaussian GPU resources. - `readonly gpuTimings: Readonly`: Most recently resolved GPU stage timings. - `readonly intervalSplats: number | null`: Splats covered by visible chunks, or `null` until readback. - `readonly loadTimings: Readonly | null`: Detailed load timings, or `null` for manually created data. - `readonly parseMilliseconds: number | null`: Total parsing time in milliseconds. - `readonly projectedSplats: number | null`: Projected splat count, or `null` until readback. - `readonly recommendedRenderScale: number`: Suggested application-managed render scale. - `readonly rendererMode: string`: Renderer path selected for the snapshot. - `readonly shColorMode: 'cached' | 'direct'`: Whether SH color is evaluated directly or through a cache. - `readonly shCpuBytes: number`: Bytes retained by CPU-side spherical-harmonic data. - `readonly shGpuBytes: number`: Bytes occupied by spherical-harmonic data on the GPU. - `readonly shRefreshes: number`: Number of SH color refreshes performed by this object. - `readonly shStorageMode: string | null`: Active spherical-harmonic storage mode. - `readonly shadowInstances: number`: Number of active shadow proxy instances. - `readonly shadowLights: number`: Number of registered shadow lights. - `readonly shadowRenders: number`: Number of completed Gaussian shadow renders. - `readonly sortedSplats: number | null`: Sorted splat count, or `null` when sorting is inactive or unread. - `readonly sourceCpuBytes: number`: Bytes retained by CPU-side source attributes. - `readonly sourceFormat: string | null`: Source format reported by the loader. - `readonly sourceGpuBytes: number`: Bytes occupied by source attributes on the GPU. - `readonly sourceSplats: number`: Number of source splats accepted by the renderer. - `readonly uploadMilliseconds: number | null`: Initial upload time in milliseconds. - `readonly visibleChunks: number | null`: GPU-visible chunk count, or `null` until an explicit readback. ### GaussianSplatsStream Kind: variable; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStream. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GaussianSplatsStream } from "three-blocks/gaussian-splats"; const GaussianSplatsStream: GaussianSplatsStreamConstructor ``` **Purpose:** Budgeted streaming Gaussian scene. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `dispose(): void`: Abort pending work and release the stream's owned Gaussian renderer. - `readonly isGaussianSplatsStream: true`: Runtime type guard. - `readonly stats: Readonly`: Cheap read-only residency and renderer diagnostic snapshot. ### GaussianSplatsStreamLODOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStreamLODOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStreamLODOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsStreamLODOptions ``` **Purpose:** LOD selection overrides for streamed Gaussian scenes. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStreamLODOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `baseDistance?: number | undefined`: Camera distance at which the first lower-detail band begins. - `behindPenalty?: number | undefined`: Distance penalty applied to cells behind the camera. - `multiplier?: number | undefined`: Geometric distance multiplier between consecutive LOD bands. ### GaussianSplatsStreamOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStreamOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStreamOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsStreamOptions ``` **Purpose:** Loading, residency, and renderer options for GaussianSplatsStream. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStreamOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `budget?: number | undefined`: Maximum resident splat budget. - `concurrency?: number | undefined`: Maximum number of concurrent cell fetches. - `evictionCooldown?: number | undefined`: Minimum residency duration in milliseconds before refinement or eviction. - `hysteresis?: number | undefined`: Fractional LOD-band hysteresis used to avoid camera-edge thrashing. - `lod?: GaussianSplatsStreamLODOptions | undefined`: Optional overrides for the manifest's LOD selection policy. - `pageSize?: number | undefined`: Splat count per residency page, rounded to the stream chunk granularity. - `splats?: GaussianSplatsStreamRendererOptions | undefined`: Safe controls forwarded to the renderer owned by the stream. ### GaussianSplatsStreamProgressEvent Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStreamProgressEvent. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStreamProgressEvent } from "three-blocks/gaussian-splats"; interface GaussianSplatsStreamProgressEvent ``` **Purpose:** Residency progress payload dispatched after a streamed scene changes. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStreamProgressEvent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly inflight: number`: Number of cell requests in flight. - `readonly residentCells: number`: Number of cells with a resident LOD. - `readonly residentSplats: number`: Number of splats currently resident. - `readonly satisfied: number`: Number of wanted cells at their target LOD. - `readonly type: 'streamprogress'`: Event discriminator. - `readonly wanted: number`: Number of cells currently wanted by the camera policy. ### GaussianSplatsStreamRendererOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStreamRendererOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStreamRendererOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsStreamRendererOptions ``` **Purpose:** Construction controls for the renderer owned by a stream. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStreamRendererOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `alphaMode?: 'straight' | 'premultiplied' | undefined`: Alpha representation expected by the renderer. - `blurAmount?: number | undefined`: Screen-space antialiasing variance. - `coordinateSystem?: 'threejs' | 'source' | undefined`: Coordinate convention used by the stream source data. - `frustumCulling?: boolean | undefined`: Whether GPU frustum culling is enabled. - `lightingMode?: 'unlit' | 'lit' | undefined`: Initial lighting behavior of the renderer. - `maxStdDev?: number | undefined`: Maximum rendered Gaussian extent in standard deviations. - `recommendedRenderScale?: number | undefined`: Application-managed render-scale recommendation reported in diagnostics. - `rendererMode?: 'auto' | 'raster' | 'compute-tiles' | undefined`: Preferred renderer path, with `auto` selecting a supported path. - `sortAlgorithm?: 'radix' | 'bitonic' | undefined`: GPU sorting strategy. - `sortEnabled?: boolean | undefined`: Whether transparent splats are depth sorted. - `sortMode?: 'radial' | 'depth' | undefined`: Sort-key interpretation used for transparent ordering. - `sortPrecision?: 'float16' | 'float32' | undefined`: Sort-key precision used by the GPU sorter. - `temporalStability?: boolean | undefined`: Whether an unchanged camera may reuse the previous projection and sort. ### GaussianSplatsStreamStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsStreamStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsStreamStats } from "three-blocks/gaussian-splats"; interface GaussianSplatsStreamStats extends GaussianSplatsStats ``` **Purpose:** Read-only residency and rendering diagnostic snapshot for a streamed scene. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsStreamStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `readonly streamCapacity: number`: Total splat capacity of the residency arena. - `readonly streamCells: number`: Number of spatial cells in the stream manifest. - `readonly streamFreePages: number`: Number of currently unused residency pages. - `readonly streamInflight: number`: Number of cell requests in flight. - `readonly streamPageSize: number`: Splat count in one residency page. - `readonly streamQueued: number`: Number of cell requests waiting for a concurrency slot. - `readonly streamResidentSplats: number`: Number of currently resident splats. ### GaussianSplatsWaitOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/GaussianSplatsWaitOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { GaussianSplatsWaitOptions } from "three-blocks/gaussian-splats"; interface GaussianSplatsWaitOptions ``` **Purpose:** Controls cancellation and timeout behavior for GaussianSplats.waitForRender. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GaussianSplatsWaitOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: none recorded. - `afterVersion?: number | undefined`: Resolve only after a render newer than this version. - `signal?: AbortSignal | undefined`: Optional cancellation signal. - `timeout?: number | undefined`: Timeout in milliseconds; zero or omission disables the timeout. ### GlbAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/GlbAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { GlbAssetDefinition } from "three-blocks/assets"; interface GlbAssetDefinition extends AssetDefinition<'glb', string, never> ``` **Purpose:** Declares GlbAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers codecs and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GlbAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly codecs?: GltfCodecConfiguration` - `readonly url: string` ### GltfAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/GltfAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { GltfAssetDefinition } from "three-blocks/assets"; interface GltfAssetDefinition extends AssetDefinition<'gltf', string, never> ``` **Purpose:** Declares GltfAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers codecs and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GltfAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly codecs?: GltfCodecConfiguration` - `readonly url: string` ### GltfCodecConfiguration Kind: interface; canonical: https://threejs-blocks.com/docs/api/GltfCodecConfiguration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { GltfCodecConfiguration } from "three-blocks/assets"; interface GltfCodecConfiguration ``` **Purpose:** Declares GltfCodecConfiguration as a public interface. It is exported from three-blocks/assets. Its declared surface covers draco, gltfCurve, ktx2, and meshopt. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for GltfCodecConfiguration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly draco?: false | {readonly decoderPath?: string;}` - `readonly gltfCurve?: boolean | {readonly extensionName?: string;}` - `readonly ktx2?: false | {readonly transcoderPath?: string;}` - `readonly meshopt?: boolean` ### GridPristine Kind: class; canonical: https://threejs-blocks.com/docs/api/GridPristine. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { GridPristine } from "three-blocks/grid-pristine"; class GridPristine extends THREE.Mesh ``` **Purpose:** Infinite grid mesh with anti-aliased lines and dual-layer composition. **Status:** Stable through the curated Pristine grid block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/grid-pristine. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/grid-pristine Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. - `attachGUI(gui: GridPristineGUI | null | undefined): this`: Attach a GUI folder with common controls. Compatible with lil-gui, dat.gui, and Three.js Inspector. - `bgColor: TSLUniformNode<'color', THREE.Color>`: Background colour drawn beneath both grid layers. - `cellSizeA: TSLUniformNode<'float', number>`: World-space cell size of the major grid layer. - `cellSizeB: TSLUniformNode<'float', number>`: World-space cell size of the minor grid layer. - `colorA: TSLUniformNode<'color', THREE.Color>`: Line colour of the major grid layer. - `colorB: TSLUniformNode<'color', THREE.Color>`: Line colour of the minor grid layer. - `computeMask: TSLFunction<[GridPristineMaskInputs], TSLFloatNode>`: Reusable TSL function that evaluates one anti-aliased grid layer. - `computePlusMask: TSLFunction<[GridPristinePlusMaskInputs], TSLFloatNode>`: Reusable TSL function that evaluates intersection-only plus marks. - `constructor(params?: GridPristineOptions)`: Create an infinite grid mesh. - `dispose(): void`: Dispose GPU resources and detach GUI. - `disposeGUI(): this`: Detach and destroy the GUI folder. - `fragmentMain: TSLFunction<[], TSLVec4Node>`: TSL fragment function assigned to the grid material. - `lineWidthA: TSLUniformNode<'float', number>`: World-space line width of the major grid layer. - `lineWidthB: TSLUniformNode<'float', number>`: World-space line width of the minor grid layer. - `opacityA: TSLUniformNode<'float', number>`: Opacity of the major grid layer. - `opacityB: TSLUniformNode<'float', number>`: Opacity of the minor grid layer. ### HdrAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/HdrAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { HdrAssetDefinition } from "three-blocks/assets"; interface HdrAssetDefinition extends AssetDefinition<'hdr', string, never> ``` **Purpose:** Declares HdrAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for HdrAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly url: string` ### HotReplacementError Kind: class; canonical: https://threejs-blocks.com/docs/api/HotReplacementError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { HotReplacementError } from "three-blocks/hmr"; class HotReplacementError extends Error ``` **Purpose:** A replacement failure that leaves the previously committed object active. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly causeValue: unknown` - `readonly cleanupError: unknown` - `constructor(phase: HotReplacementPhase, causeValue: unknown, cleanupError?: unknown)` - `readonly phase: HotReplacementPhase` ### HotReplacementPhase Kind: type; canonical: https://threejs-blocks.com/docs/api/HotReplacementPhase. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { HotReplacementPhase } from "three-blocks/hmr"; type HotReplacementPhase = 'capture' | 'create' | 'restore' | 'prepare' | 'compile' | 'commit' ``` **Purpose:** Declares HotReplacementPhase as a public type. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for HotReplacementPhase. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### HotScene Kind: interface; canonical: https://threejs-blocks.com/docs/api/HotScene. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { HotScene } from "three-blocks/hmr"; interface HotScene ``` **Purpose:** Declares HotScene as a public interface. It is exported from three-blocks/hmr. Its declared surface covers captureHotState, dispose, hot, and restoreHotState. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `captureHotState?(): TState` - `dispose(): MaybePromise` - `readonly hot?: object`: Shallow, declared state whose compatible fields survive scene replacement. - `restoreHotState?(state: TState): MaybePromise` ### HotSceneFactory Kind: type; canonical: https://threejs-blocks.com/docs/api/HotSceneFactory. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { HotSceneFactory } from "three-blocks/hmr"; type HotSceneFactory = (context: TContext) => MaybePromise ``` **Purpose:** Declares HotSceneFactory as a public type. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for HotSceneFactory. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### HydratedBuilderState Kind: interface; canonical: https://threejs-blocks.com/docs/api/HydratedBuilderState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { HydratedBuilderState } from "three-blocks/shaders"; interface HydratedBuilderState ``` **Purpose:** Declares HydratedBuilderState as a public interface. It is exported from three-blocks/shaders. Its declared surface covers attributes, bindings, computeShader, fragmentShader, and hardwareClipping, plus 6 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for HydratedBuilderState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attributes: readonly unknown[]` - `readonly bindings: readonly ShaderBindingGroupLike[]` - `readonly computeShader: string | null` - `readonly fragmentShader: string | null` - `readonly hardwareClipping: boolean` - `readonly observer: unknown` - `readonly transforms: readonly unknown[]` - `readonly updateAfterNodes: readonly ShaderNodeLike[]` - `readonly updateBeforeNodes: readonly ShaderNodeLike[]` - `readonly updateNodes: readonly ShaderNodeLike[]` - `readonly vertexShader: string | null` ### ImageAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/ImageAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ImageAssetDefinition } from "three-blocks/assets"; interface ImageAssetDefinition extends AssetDefinition<'image', string, never> ``` **Purpose:** Declares ImageAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers colorSpace, format, and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ImageAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly colorSpace?: string` - `readonly format?: ImageAssetFormat` - `readonly url: string` ### ImageAssetFormat Kind: type; canonical: https://threejs-blocks.com/docs/api/ImageAssetFormat. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ImageAssetFormat } from "three-blocks/assets"; type ImageAssetFormat = 'png' | 'jpeg' | 'webp' | 'avif' ``` **Purpose:** Declares ImageAssetFormat as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ImageAssetFormat. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### IndirectBatchedMesh Kind: variable; canonical: https://threejs-blocks.com/docs/api/IndirectBatchedMesh. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { IndirectBatchedMesh } from "three-blocks"; import { IndirectBatchedMesh } from "three-blocks/indirect-batching"; const IndirectBatchedMesh: IndirectBatchedMeshConstructor ``` **Purpose:** Stable Three.js mesh facade for packing heterogeneous geometry into one GPU-driven indirect batch. It preserves the runtime engine's `Mesh` identity, so the result can be added to a scene and configured through normal Object3D properties. Construction allocates the merged geometry and instance storage; invalid capacities, incompatible geometry layouts, exhausted capacity, and out-of-range IDs make the corresponding operation throw. The batch owns its merged geometry and GPU instance/culling resources, while source geometries, materials, renderer, camera, and matrices remain caller-owned. Internal culling runs automatically immediately before rendering; call IndirectBatchedMesh.updateInternalCulling only when an explicit earlier dispatch is required. Detach the mesh, then call IndirectBatchedMesh.dispose; do not use it afterward. Runtime-identical constructor for the narrow stable indirect-batching facade. **Status:** Stable through the curated Indirect Batching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/indirect-batching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/indirect-batching Direct example imports: https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility. - `addGeometry(geometry: BufferGeometry, reservedVertexCount?: number, reservedIndexCount?: number): IndirectBatchedMeshGeometryId`: Copy compatible source geometry into reserved merged storage and return its ID. - `addInstance(geometryId: IndirectBatchedMeshGeometryId): IndirectBatchedMeshInstanceId`: Allocate an instance of an existing geometry and return its stable slot ID. - `beginBulkUpdate(): this`: Defer CPU indirect-command rebuilds while adding or removing many items. - `new (maxInstanceCount: number, maxVertexCount: number, maxIndexCount?: number, material?: IndirectBatchedMeshMaterial): IndirectBatchedMesh`: Construct a stable indirect batch with fixed instance and merged-geometry capacities. - `deleteGeometry(geometryId: IndirectBatchedMeshGeometryId): this`: Mark a geometry and all of its instances inactive, returning their slots to the pool. - `deleteInstance(instanceId: IndirectBatchedMeshInstanceId): this`: Mark an instance inactive and return its slot to the reusable pool. - `dispose(): void`: Dispose merged geometry and invalidate the batch's owned storage references. - `enableInternalCulling(renderer: WebGPURenderer): this`: Allocate the batch-owned culling pipeline; automatic rendering also does this lazily. - `endBulkUpdate(rebuild?: boolean): this`: Resume command rebuilds after a bulk update and optionally flush immediately. - `getBoundingBoxAt(geometryId: IndirectBatchedMeshGeometryId, target: Box3): Box3 | null`: Read the bounds of packed geometry into a caller-provided box. - `getBoundingSphereAt(geometryId: IndirectBatchedMeshGeometryId, target: Sphere): Sphere | null`: Read the bounds of packed geometry into a caller-provided sphere. - `getColorAt(instanceId: IndirectBatchedMeshInstanceId, color: Color): Color`: Copy one active instance color into a caller-provided color. - `getMatrixAt(instanceId: IndirectBatchedMeshInstanceId, matrix: Matrix4): Matrix4`: Copy one active instance transform into a caller-provided matrix. - `readonly instanceCount: number`: Number of currently active instances. - `readonly isIndirectBatchedMesh: true`: Runtime type guard for the stable indirect-batching facade. - `readonly maxInstanceCount: number`: Maximum number of instances reserved at construction. - `optimize(): this`: Compact inactive geometry gaps after a mutation batch has settled. - `perObjectFrustumCulled: boolean`: Enable or bypass per-instance frustum rejection without rebuilding the culler. - `setColorAt(instanceId: IndirectBatchedMeshInstanceId, color: Color): this`: Copy a caller-owned color into one active instance slot, allocating color storage lazily. - `setMatrixAt(instanceId: IndirectBatchedMeshInstanceId, matrix: Matrix4): this`: Copy a caller-owned matrix into one active instance slot. - `updateInternalCulling(camera?: Camera): this`: Submit internal culling after transforms/camera updates and before rendering. ### IndirectBatchedMeshGeometryId Kind: type; canonical: https://threejs-blocks.com/docs/api/IndirectBatchedMeshGeometryId. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { IndirectBatchedMeshGeometryId } from "three-blocks/indirect-batching"; type IndirectBatchedMeshGeometryId = number ``` **Purpose:** Stable slot identifier returned when geometry is added to a batch. **Status:** Stable through the curated Indirect Batching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for IndirectBatchedMeshGeometryId. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/indirect-batching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/indirect-batching Direct example imports: none recorded. ### IndirectBatchedMeshInstanceId Kind: type; canonical: https://threejs-blocks.com/docs/api/IndirectBatchedMeshInstanceId. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { IndirectBatchedMeshInstanceId } from "three-blocks/indirect-batching"; type IndirectBatchedMeshInstanceId = number ``` **Purpose:** Stable slot identifier returned when an instance is added to a batch. **Status:** Stable through the curated Indirect Batching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for IndirectBatchedMeshInstanceId. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/indirect-batching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/indirect-batching Direct example imports: none recorded. ### IndirectBatchedMeshMaterial Kind: type; canonical: https://threejs-blocks.com/docs/api/IndirectBatchedMeshMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { IndirectBatchedMeshMaterial } from "three-blocks/indirect-batching"; type IndirectBatchedMeshMaterial = Material | Material[] ``` **Purpose:** Material shape accepted by an indirect batch. **Status:** Stable through the curated Indirect Batching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for IndirectBatchedMeshMaterial. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/indirect-batching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/indirect-batching Direct example imports: none recorded. ### InputForwarder Kind: class; canonical: https://threejs-blocks.com/docs/api/InputForwarder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { InputForwarder } from "three-blocks/app"; class InputForwarder ``` **Purpose:** Small verb-based facade for page input; unchanged scroll frames are not transported. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(worker: WorkerLink)` - `pointer(value: PointerState): void` - `scroll(value: ScrollState): void` - `viewport(value: ViewportState): void` - `visibility(value: VisibilityState): void` ### InspectThreeBlocksProjectOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/InspectThreeBlocksProjectOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { InspectThreeBlocksProjectOptions } from "three-blocks/vite"; interface InspectThreeBlocksProjectOptions ``` **Purpose:** Declares InspectThreeBlocksProjectOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers publicDir, text, threeBlocksShaderClosure, threeBlocksVersion, and threeVersion. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for InspectThreeBlocksProjectOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly publicDir?: string`: Absolute public directory for the asset-candidate scan; defaults to `/public`. - `readonly text?: TextConfiguration` - `readonly threeBlocksShaderClosure?: string`: Installed `three-blocks/shaders` ESM closure; populated internally by normal Vite inspection. - `readonly threeBlocksVersion?: string` - `readonly threeVersion: string` ### InstallShaderCacheOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/InstallShaderCacheOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { InstallShaderCacheOptions } from "three-blocks/shaders"; interface InstallShaderCacheOptions ``` **Purpose:** Declares InstallShaderCacheOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers cache, compatibility, loadManifest, logger, and renderer, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for InstallShaderCacheOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cache?: ShaderCache` - `readonly compatibility: ShaderCompatibility` - `readonly loadManifest: (scene: string, backend: 'webgpu' | 'webgl') => unknown | PromiseLike` - `readonly logger?: ShaderRuntimeLogger` - `readonly renderer: object` - `readonly scene: string` - `readonly state: ShaderBuildState` ### JsonAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/JsonAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { JsonAssetDefinition } from "three-blocks/assets"; interface JsonAssetDefinition extends AssetDefinition<'json', string, never> ``` **Purpose:** Declares JsonAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for JsonAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly url: string` ### KinematicInteractionShape Kind: type; canonical: https://threejs-blocks.com/docs/api/KinematicInteractionShape. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { KinematicInteractionShape } from "three-blocks/experimental/gpu-interaction"; type KinematicInteractionShape = {type: 'sphere'; radius: number;} | {type: 'box'; halfExtents: readonly [number, number, number];} | {type: 'capsule'; radius: number; halfHeight: number;} ``` **Purpose:** Supported high-level shape descriptors for a CPU-driven kinematic source. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for KinematicInteractionShape. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. ### KinematicInteractionSource Kind: variable; canonical: https://threejs-blocks.com/docs/api/KinematicInteractionSource. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { KinematicInteractionSource } from "three-blocks/experimental/gpu-interaction"; const KinematicInteractionSource: KinematicInteractionSourceConstructor ``` **Purpose:** CPU-driven single-collider source. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `readonly capacity: 1`: This source always reserves one collider slot. - `new (options?: KinematicInteractionSourceOptions): KinematicInteractionSource`: Construct a one-collider CPU transform source. - `detach(): void`: Detach from the world without disposing the target object. - `dispose(): void`: Release the world association and target reference. - `setTarget(object: THREE.Object3D | null): this`: Select the application-owned object to sample, or `null` to disable it. - `readonly target: THREE.Object3D | null`: Application-owned object sampled during the next world frame. ### KinematicInteractionSourceOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/KinematicInteractionSourceOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { KinematicInteractionSourceOptions } from "three-blocks/experimental/gpu-interaction"; interface KinematicInteractionSourceOptions ``` **Purpose:** Construction controls for KinematicInteractionSource. **Status:** Experimental through the curated GPU Interaction block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for KinematicInteractionSourceOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/gpu-interaction. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/gpu-interaction Direct example imports: none recorded. - `affects?: readonly ('boids' | 'fluid' | 'smoke')[] | undefined`: Simulation families that sense this collider. - `friction?: number | undefined`: Surface friction coefficient. - `layer?: number | undefined`: Interaction layer bit field. - `mask?: number | undefined`: Interaction mask bit field. - `restitution?: number | undefined`: Surface restitution coefficient. - `shape?: KinematicInteractionShape | undefined`: Local collider shape sampled at the target object's world transform. ### Ktx2AssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/Ktx2AssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { Ktx2AssetDefinition } from "three-blocks/assets"; interface Ktx2AssetDefinition extends AssetDefinition<'ktx2', string, never> ``` **Purpose:** Declares Ktx2AssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers transcoderPath and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for Ktx2AssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly transcoderPath?: string` - `readonly url: string` ### KuwaharaOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/KuwaharaOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { KuwaharaOptions } from "three-blocks/core-tsl-effects"; interface KuwaharaOptions ``` **Purpose:** Quality and appearance controls for the stable Kuwahara painterly filter. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for KuwaharaOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. - `angleSteps?: number`: Number of discrete angle samples per sector. - `anisotropy?: number`: Stroke elongation along coherent image edges. - `debug?: boolean`: Whether to output diagnostic sector, coherence, and variance channels. - `edgePreservation?: number`: Mix of the untouched center color retained near coherent edges. - `radius?: number`: Filter radius in pixels. - `rangeSensitivity?: number`: Color-boundary rejection strength, or zero to disable range weighting. - `sectorBlend?: number`: Soft transition amount between the two lowest-variance sectors. - `sectors?: number`: Number of angular sectors sampled around each pixel. - `stepSize?: number`: Pixel stride between spatial samples. - `useSimpleWeight?: boolean`: Whether to use the lower-cost flat spatial weighting function. - `useTensor?: boolean`: Whether structure-tensor orientation should guide the filter. - `varianceSensitivity?: number`: Rejection strength for noisier candidate sectors. ### LOD_MODE_EXP Kind: variable; canonical: https://threejs-blocks.com/docs/api/LOD_MODE_EXP. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { LOD_MODE_EXP } from "three-blocks/instance-culling"; const LOD_MODE_EXP: 2 ``` **Purpose:** Exponential density LOD (falls off from `lodNear` with `lodDensity`). **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for LOD_MODE_EXP. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### LoadedTextFont Kind: interface; canonical: https://threejs-blocks.com/docs/api/LoadedTextFont. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { LoadedTextFont } from "three-blocks/text/worker"; interface LoadedTextFont ``` **Purpose:** Declares LoadedTextFont as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers font, map, and release. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: release. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly font: TextFontMetrics` - `readonly map: TextTexture` - `release?(): void`: Called after every batch using this load is disposed. Must be idempotent. ### MPMBoundaryOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMBoundaryOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMBoundaryOptions } from "three-blocks/mpm"; interface MPMBoundaryOptions ``` **Purpose:** Normalized-domain boundary controls applied during particle/grid updates. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMBoundaryOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `floorFriction: number`: Tangential velocity multiplier applied at the floor. - `margin: number`: Grid-cell inset that defines the active domain boundary. - `velocityDamping: number`: Per-step velocity damping applied at boundaries. - `wallPushback: number`: Inward velocity applied when particles cross a wall. ### MPMCFLConfiguration Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMCFLConfiguration. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMCFLConfiguration } from "three-blocks/mpm"; interface MPMCFLConfiguration ``` **Purpose:** Courant–Friedrichs–Lewy substep controls. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMCFLConfiguration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `maxSubsteps?: number | undefined`: Upper bound for adaptive substeps. - `target?: number | undefined`: Maximum normalized travel distance allowed per substep. ### MPMComputeBatch Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMComputeBatch. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMComputeBatch } from "three-blocks/mpm"; interface MPMComputeBatch extends Array ``` **Purpose:** Compute-node array carrying Three.js batch metadata. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMComputeBatch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `id: string`: Stable batch identifier consumed by the renderer. - `isComputeNode: true`: Renderer marker identifying the array as one compute node. - `name: string`: Human-readable compute batch name. ### MPMCoreGraph Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMCoreGraph. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMCoreGraph } from "three-blocks/mpm"; interface MPMCoreGraph ``` **Purpose:** Paired kernel lookup and ordered compute batch for one solver graph. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMCoreGraph. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `kernels: MPMCoreKernels`: Named kernels for inspection and dispatch-size updates. - `passes: MPMComputeBatch`: Ordered passes submitted for each substep. ### MPMCoreKernels Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMCoreKernels. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMCoreKernels } from "three-blocks/mpm"; interface MPMCoreKernels ``` **Purpose:** Named compute kernels that make up one MPM substep. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMCoreKernels. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `clearGrid: ComputeNode`: Clears atomic grid state before transfer. - `g2p: ComputeNode`: Transfers grid state back to particles. - `gridUpdate: ComputeNode`: Updates grid velocity, forces, and boundaries. - `p2g?: ComputeNode | undefined`: Fused particle-to-grid transfer when using the production formulation. - `p2gScatter?: ComputeNode | undefined`: Reference-formulation particle mass and momentum scatter. - `p2gStress?: ComputeNode | undefined`: Reference-formulation stress scatter. ### MPMDiagnosticsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMDiagnosticsOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMDiagnosticsOptions } from "three-blocks/mpm"; interface MPMDiagnosticsOptions ``` **Purpose:** Opt-in asynchronous solver diagnostics. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMDiagnosticsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `overflowAudit?: boolean | undefined`: Audit fixed-point grid accumulation for overflow risk. ### MPMDiagnosticsSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMDiagnosticsSnapshot. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMDiagnosticsSnapshot } from "three-blocks/mpm"; interface MPMDiagnosticsSnapshot ``` **Purpose:** Latest resolved diagnostic counters from GPU storage. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMDiagnosticsSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `mass: number`: Accumulated fixed-point particle mass. - `momentum: number`: Accumulated fixed-point momentum magnitude. - `overflow: boolean`: Whether mass or momentum reached the audited fixed-point limit. - `speedSquared: number`: Maximum squared particle speed encoded by the diagnostic pass. ### MPMElasticModel Kind: class; canonical: https://threejs-blocks.com/docs/api/MPMElasticModel. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MPMElasticModel } from "three-blocks/mpm"; class MPMElasticModel implements MPMMaterialModel ``` **Purpose:** Fixed-corotated elastic model proving that solver kernels are material-agnostic. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `constructor({youngsModulus, poissonRatio, volume, density}?: MPMElasticModelOptions)`: Create a fixed-corotated material and derive its Lamé parameters. - `initParticle({particle}: MPMMaterialParticleContext): void`: Initialize deformation to identity and store material density. - `name: 'elastic'`: Stable material identifier. - `particleFields: MPMElasticParticleFields`: Elastic deformation-gradient particle field. - `stress({particle}: MPMMaterialStressContext): TSLMat3Node`: Evaluate fixed-corotated elastic stress for one particle. - `uniforms: MPMElasticUniforms`: Live Lamé, volume, and density controls. - `updateDeformation({particle, C, dt}: MPMMaterialUpdateContext): void`: Advance the deformation gradient from the affine velocity field. ### MPMElasticModelOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMElasticModelOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMElasticModelOptions } from "three-blocks/mpm"; interface MPMElasticModelOptions ``` **Purpose:** Parameters for the fixed-corotated elastic material. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMElasticModelOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `density?: number | undefined`: Initial particle density. - `poissonRatio?: number | undefined`: Poisson ratio controlling transverse deformation. - `volume?: number | undefined`: Reference particle volume used by the stress calculation. - `youngsModulus?: number | undefined`: Young's modulus controlling elastic stiffness. ### MPMElasticParticleFields Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMElasticParticleFields. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMElasticParticleFields } from "three-blocks/mpm"; interface MPMElasticParticleFields extends MPMParticleFieldMap ``` **Purpose:** Material-owned particle fields required for elastic deformation. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMElasticParticleFields. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `F: {type: 'mat3';}`: Persistent deformation-gradient matrix. ### MPMElasticUniforms Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMElasticUniforms. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMElasticUniforms } from "three-blocks/mpm"; interface MPMElasticUniforms ``` **Purpose:** Mutable TSL uniforms derived for MPMElasticModel. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMElasticUniforms. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `density: TSLUniformNode<'float', number>`: Initial particle density. - `lambda: TSLUniformNode<'float', number>`: Second Lamé parameter. - `mu: TSLUniformNode<'float', number>`: First Lamé shear parameter. - `volume: TSLUniformNode<'float', number>`: Reference particle volume. ### MPMFluidModel Kind: class; canonical: https://threejs-blocks.com/docs/api/MPMFluidModel. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MPMFluidModel } from "three-blocks/mpm"; class MPMFluidModel implements MPMMaterialModel ``` **Purpose:** Gamma=1 Tait fluid material used by the ocean example. Density is carried in particle.velocity.w, leaving the 80-byte std430 particle stride unchanged. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. - `constructor({stiffness, restDensity, viscosity}?: MPMFluidModelOptions)`: Create a fluid material with mutable TSL uniforms. - `initParticle({particle}: MPMMaterialParticleContext): void`: Store rest density in the core velocity metadata lane. - `name: 'fluid'`: Stable material identifier. - `particleFields: MPMParticleFieldMap`: Fluid model adds no fields beyond the core particle layout. - `stress({C, density}: MPMMaterialStressContext): TSLMat3Node`: Evaluate pressure and viscosity stress for one particle. - `uniforms: MPMFluidUniforms`: Live pressure, density, and viscosity controls. - `updateDeformation(): void`: Fluid particles have no persistent deformation state to update. Accept the shared material callback signature without changing state. - `updateDeformation(context: MPMMaterialUpdateContext): void`: Fluid particles have no persistent deformation state to update. Accept the shared material callback signature without changing state. ### MPMFluidModelOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMFluidModelOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMFluidModelOptions } from "three-blocks/mpm"; interface MPMFluidModelOptions ``` **Purpose:** Parameters for the built-in pressure-and-viscosity fluid model. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMFluidModelOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `restDensity?: number | undefined`: Target particle density. - `stiffness?: number | undefined`: Tait pressure stiffness. - `viscosity?: number | undefined`: Symmetric affine-velocity viscosity coefficient. ### MPMFluidUniforms Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMFluidUniforms. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMFluidUniforms } from "three-blocks/mpm"; interface MPMFluidUniforms ``` **Purpose:** Mutable TSL uniforms owned by MPMFluidModel. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMFluidUniforms. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `restDensity: TSLUniformNode<'float', number>`: Rest-density uniform. - `stiffness: TSLUniformNode<'float', number>`: Pressure stiffness uniform. - `viscosity: TSLUniformNode<'float', number>`: Viscosity uniform. ### MPMFormulation Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMFormulation. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMFormulation } from "three-blocks/mpm"; type MPMFormulation = 'fused' | 'reference' ``` **Purpose:** Kernel graph shape used for particle-to-grid transfer. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMFormulation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMGranularModel Kind: class; canonical: https://threejs-blocks.com/docs/api/MPMGranularModel. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MPMGranularModel } from "three-blocks/mpm"; class MPMGranularModel implements MPMMaterialModel ``` **Purpose:** Drucker-Prager-lite granular material with no extra particle fields. Pressure supplies the Coulomb yield cap; RPIC damping removes residual shear while retaining the antisymmetric APIC spin used by render pose passes. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility. - `constructor({stiffness, restDensity, friction, flowViscosity, shearDamping,}?: MPMGranularModelOptions)`: Create a granular material with mutable pressure, friction, and damping controls. - `initParticle({particle}: MPMMaterialParticleContext): void`: Initialize material-owned state for one seeded particle. - `name: 'granular'`: Stable material identifier used by diagnostics and tooling. - `particleFields: MPMParticleFieldMap`: Material-owned fields appended to the particle struct. - `stress({C, density}: MPMMaterialStressContext): TSLMat3Node`: Return the material stress contribution for one particle. - `uniforms: MPMGranularUniforms`: Mutable material parameters captured by the kernel graph. - `updateDeformation({particle, C}: MPMMaterialUpdateContext): void`: Update material deformation state after grid-to-particle transfer. ### MPMGranularModelOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMGranularModelOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMGranularModelOptions } from "three-blocks/mpm"; interface MPMGranularModelOptions ``` **Purpose:** Parameters for the Coulomb-capped granular material. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMGranularModelOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `flowViscosity?: number | undefined`: Viscosity below the Coulomb yield cap. - `friction?: number | undefined`: Coulomb friction coefficient. - `restDensity?: number | undefined`: Target particle density. - `shearDamping?: number | undefined`: Fraction of symmetric APIC shear removed after each transfer. - `stiffness?: number | undefined`: Tait pressure stiffness. ### MPMGranularUniforms Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMGranularUniforms. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMGranularUniforms } from "three-blocks/mpm"; interface MPMGranularUniforms ``` **Purpose:** Mutable TSL uniforms owned by MPMGranularModel. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMGranularUniforms. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `flowViscosity: TSLUniformNode<'float', number>`: Pre-yield viscosity uniform. - `friction: TSLUniformNode<'float', number>`: Coulomb friction uniform. - `restDensity: TSLUniformNode<'float', number>`: Rest-density uniform. - `shearDamping: TSLUniformNode<'float', number>`: Symmetric APIC damping uniform. - `stiffness: TSLUniformNode<'float', number>`: Pressure stiffness uniform. ### MPMGridForce Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMGridForce. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMGridForce } from "three-blocks/mpm"; type MPMGridForce = (context: MPMGridForceContext) => void ``` **Purpose:** TSL callback that applies a custom force to one grid cell. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMGridForce. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMGridForceContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMGridForceContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMGridForceContext } from "three-blocks/mpm"; interface MPMGridForceContext ``` **Purpose:** Mutable TSL values supplied to a custom grid-force hook. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMGridForceContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `cell: MPMIVec3Node`: Integer coordinate of the current grid cell. - `dt: TSLFloatNode`: Current solver substep duration. - `mass: TSLFloatNode`: Mass accumulated in the current grid cell. - `position: TSLVec3Node`: Normalized-domain cell-center position. - `time: TSLFloatNode`: Simulation time at the start of the frame. - `velocity: TSLVec3Node`: Mutable mass-normalized grid velocity. ### MPMIntegrationProfile Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMIntegrationProfile. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMIntegrationProfile } from "three-blocks/mpm"; type MPMIntegrationProfile = 'production' | 'three-r185-strict' ``` **Purpose:** Runtime behavior profile for production or byte-comparable r185 capture. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMIntegrationProfile. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMMaterialModel Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMMaterialModel. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMMaterialModel } from "three-blocks/mpm"; interface MPMMaterialModel ``` **Purpose:** Six-member runtime contract accepted by `MPMSolver`. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMMaterialModel. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `initParticle(context: MPMMaterialParticleContext): void`: Initialize material-owned state for one seeded particle. - `name: string`: Stable material identifier used by diagnostics and tooling. - `particleFields: MPMParticleFieldMap`: Material-owned fields appended to the particle struct. - `stress(context: MPMMaterialStressContext): TSLMat3Node`: Return the material stress contribution for one particle. - `uniforms: TUniforms`: Mutable material parameters captured by the kernel graph. - `updateDeformation(context: MPMMaterialUpdateContext): void`: Update material deformation state after grid-to-particle transfer. ### MPMMaterialParticleContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMMaterialParticleContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMMaterialParticleContext } from "three-blocks/mpm"; interface MPMMaterialParticleContext ``` **Purpose:** Particle access supplied to material initialization. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMMaterialParticleContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `index?: TSLUintNode | undefined`: Current particle index when the calling pass exposes it. - `particle: MPMParticleNode`: Narrow typed view of the current particle struct. ### MPMMaterialStressContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMMaterialStressContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMMaterialStressContext } from "three-blocks/mpm"; interface MPMMaterialStressContext extends MPMMaterialParticleContext ``` **Purpose:** Particle and transfer values supplied while evaluating material stress. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMMaterialStressContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `C: TSLMat3Node`: Affine particle velocity field. - `density: TSLFloatNode`: Current particle density. - `dt: TSLFloatNode`: Current solver substep duration. ### MPMMaterialUpdateContext Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMMaterialUpdateContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMMaterialUpdateContext } from "three-blocks/mpm"; type MPMMaterialUpdateContext = MPMMaterialStressContext ``` **Purpose:** Context supplied when a material updates deformation after grid transfer. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMMaterialUpdateContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMP2GMode Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMP2GMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMP2GMode } from "three-blocks/mpm"; type MPMP2GMode = MPMGridContributionMode | 'auto' ``` **Purpose:** Requested particle-to-grid implementation, including feature detection. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMP2GMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMParticleField Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMParticleField. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleField } from "three-blocks/mpm"; interface MPMParticleField ``` **Purpose:** One material-owned field appended to the solver's particle struct. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleField. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `type: MPMParticleFieldType`: TSL storage type appended to each particle. ### MPMParticleFieldMap Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMParticleFieldMap. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleFieldMap } from "three-blocks/mpm"; type MPMParticleFieldMap = Record ``` **Purpose:** Material-owned fields keyed by their runtime struct member names. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleFieldMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMParticleFieldType Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMParticleFieldType. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleFieldType } from "three-blocks/mpm"; type MPMParticleFieldType = 'float' | 'int' | 'uint' | 'vec2' | 'ivec2' | 'uvec2' | 'vec3' | 'ivec3' | 'uvec3' | 'vec4' | 'ivec4' | 'uvec4' | 'mat2' | 'mat3' | 'mat4' ``` **Purpose:** Scalar/vector/matrix field types supported by the MPM particle struct. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleFieldType. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMParticleForce Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMParticleForce. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleForce } from "three-blocks/mpm"; type MPMParticleForce = (context: MPMParticleForceContext) => void ``` **Purpose:** TSL callback that applies a custom per-particle force. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleForce. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMParticleForceContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMParticleForceContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleForceContext } from "three-blocks/mpm"; interface MPMParticleForceContext ``` **Purpose:** Mutable TSL values supplied to a custom particle-force hook. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleForceContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `density: TSLFloatNode`: Current particle density. - `dt: TSLFloatNode`: Current solver substep duration. - `position: TSLVec3Node`: Current normalized-domain particle position. - `velocity: TSLVec3Node`: Mutable particle velocity. ### MPMParticleNode Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMParticleNode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleNode } from "three-blocks/mpm"; interface MPMParticleNode ``` **Purpose:** Narrow particle struct access used by the built-in material models. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `get(field: 'C' | 'F'): TSLMat3Node`: Read a built-in vector field from the particle struct. Read a built-in matrix field from the particle struct. Read a custom material-owned field from the particle struct. - `get(field: 'position' | 'velocity'): TSLVec4Node`: Read a built-in vector field from the particle struct. Read a built-in matrix field from the particle struct. Read a custom material-owned field from the particle struct. - `get(field: string): TSLNode`: Read a built-in vector field from the particle struct. Read a built-in matrix field from the particle struct. Read a custom material-owned field from the particle struct. ### MPMParticleUpdate Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMParticleUpdate. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleUpdate } from "three-blocks/mpm"; type MPMParticleUpdate = (context: MPMParticleUpdateContext) => void ``` **Purpose:** TSL callback that observes or adjusts an updated particle. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMParticleUpdateContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMParticleUpdateContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMParticleUpdateContext } from "three-blocks/mpm"; interface MPMParticleUpdateContext extends Omit ``` **Purpose:** Mutable TSL values supplied after grid-to-particle transfer. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMParticleUpdateContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `index: TSLUintNode`: Current particle index. ### MPMPostPasses Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMPostPasses. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMPostPasses } from "three-blocks/mpm"; type MPMPostPasses = MPMPostPassList | ((context: MPMStepPostPassContext) => MPMPostPassList) ``` **Purpose:** Static or frame-resolved compute passes appended to each solver submission. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMPostPasses. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMResolvedSortingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMResolvedSortingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMResolvedSortingOptions } from "three-blocks/mpm"; interface MPMResolvedSortingOptions ``` **Purpose:** Normalized sorting values stored by the solver. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMResolvedSortingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `blockSize: number`: Positive grid-cell block size. - `interval: number`: Positive frame interval between sorting passes. ### MPMSeedContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMSeedContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSeedContext } from "three-blocks/mpm"; interface MPMSeedContext ``` **Purpose:** TSL values available while initializing one particle. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSeedContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `index: TSLUintNode`: Active particle index. ### MPMSeedInitializer Kind: type; canonical: https://threejs-blocks.com/docs/api/MPMSeedInitializer. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSeedInitializer } from "three-blocks/mpm"; type MPMSeedInitializer = (context: MPMSeedContext) => MPMSeedState | null | undefined | void ``` **Purpose:** TSL callback that initializes one active particle. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSeedInitializer. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. ### MPMSeedState Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMSeedState. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSeedState } from "three-blocks/mpm"; interface MPMSeedState ``` **Purpose:** Optional particle state returned from a seed initializer. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSeedState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `position?: TSLVec3Node | undefined`: Normalized-domain particle position. - `velocity?: TSLVec3Node | undefined`: Initial normalized-domain particle velocity. ### MPMSolver Kind: class; canonical: https://threejs-blocks.com/docs/api/MPMSolver. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MPMSolver } from "three-blocks/mpm"; class MPMSolver ``` **Purpose:** Reusable WebGPU MLS-MPM/APIC solver over a normalized [0,1]^3 domain. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. - `boundary: MPMBoundaryOptions`: Resolved normalized-domain boundary behavior. - `capacity: number`: Maximum allocated particle count. - `cfl: MPMCFLConfiguration | null`: Adaptive substep policy, or null when disabled. - `constructor({capacity, gridSize, material, formulation, integrationProfile, gravity, maxVelocity, workgroupSize, substeps, cfl, sorting, p2gMode, densityPrediction, packedGridMirror, boundary, diagnostics, gridForce, particleForce, onParticleUpdate, postPasses,}?: MPMSolverOptions)`: Allocate a reusable solver graph and its fixed-capacity GPU storage. - `densityPrediction: boolean`: Whether density is predicted during particle-to-grid transfer. - `diagnostics: MPMDiagnosticsOptions | null`: Opt-in diagnostic policy, or null when disabled. - `diagnosticsBuffer: TSLStorageNode<'uint'> | null`: Optional atomic diagnostic counters. - `dispose(): void`: Release solver-owned compute nodes, storage, sorting, and readback state. - `formulation: MPMFormulation`: Fused or split-reference kernel formulation. - `frame: number`: Number of completed solver frames. - `getLastStepStats(): MPMStepStats`: Return a defensive snapshot of the most recent step statistics. - `gridAtomicBuffer: TSLStorageNode<'struct'>`: Atomic fixed-point transfer grid. - `gridCellCount: number`: Total number of allocated grid cells. - `gridForce: MPMGridForce | null`: Optional caller hook applied during grid update. - `gridMirrorBuffer: MPMGridMirrorStorageNode`: Read-only float or packed grid state after transfer. - `gridSize: Vector3`: Integer dimensions of the transfer grid. - `integrationProfile: MPMIntegrationProfile`: Active production or strict-comparison behavior. - `kernels: MPMCoreKernels | null`: Named kernels for the primary unsorted graph. - `lastStepStats: MPMStepStats`: Statistics captured for the most recent step. - `lastSubmittedBatch: MPMComputeBatch | null`: Exact compute batch submitted by the most recent step. - `loadParticleState(state: Float32Array, particleCount?: number): this`: Replace the active particle prefix from a shared CPU fixture and reset time. The byte-compatible strict r185 fixture uses the solver's 20-float fluid stride; material-specific structs are accepted when their full stride is supplied. Loading happens outside the measured step graph. - `material: MPMMaterialModel`: Constitutive model and material-owned particle fields. - `onParticleUpdate: MPMParticleUpdate | null`: Optional caller hook invoked with updated particle state. - `p2gMode: MPMP2GMode`: Requested particle-to-grid implementation. - `packedGridMirror: boolean`: Whether the read-only grid mirror uses packed half precision. - `particleBuffer: TSLStorageNode<'struct'>`: Primary GPU particle struct storage consumed by render mirrors. - `get particleCount(): number`: Active prefix of the allocated particle storage. Clamp and apply the active particle prefix to every particle dispatch. - `set particleCount(value: number)`: Active prefix of the allocated particle storage. Clamp and apply the active particle prefix to every particle dispatch. - `particleForce: MPMParticleForce | null`: Optional caller hook applied during particle update. - `particlePongBuffer: TSLStorageNode<'struct'> | null`: Alternate particle storage allocated when sorting is enabled. - `passes: MPMComputeBatch | null`: Ordered primary compute batch. - `postPasses: MPMPostPasses | null`: Caller-owned compute passes appended to a frame submission. - `readParticleState(renderer: Renderer): Promise`: Read the exact active particle prefix from GPU storage. - `resetParticleState(renderer: Renderer, state?: Float32Array | null, particleCount?: number | null): Promise`: Restore the immutable strict source into active GPU particle storage. - `resolveDiagnostics(renderer?: Renderer | null): Promise`: Resolve the latest opt-in CFL/overflow counters. - `resolvedP2GMode: MPMGridContributionMode`: Particle-to-grid implementation selected for the last frame. - `seed(renderer: Renderer, initializer?: MPMSeedInitializer | null): this`: GPU particle initialization; safe to call again to reset the solver. - `sorting: MPMResolvedSortingOptions | null`: Resolved locality-sorting policy, or null when disabled. - `step(renderer: Renderer, dt: number): this`: Advance all configured substeps in one renderer.compute() submission. - `substeps: number`: Minimum fixed substeps submitted per frame. - `time: number`: Accumulated simulation time in seconds. - `uniforms: MPMSolverUniforms`: Mutable uniforms shared by all solver kernels. - `workgroupSize: number`: Particle compute workgroup width. ### MPMSolverOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMSolverOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSolverOptions } from "three-blocks/mpm"; interface MPMSolverOptions ``` **Purpose:** Construction options for MPMSolver. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSolverOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `boundary?: Partial | undefined`: Partial normalized-domain boundary behavior. - `capacity?: number | undefined`: Maximum allocated particle count. - `cfl?: MPMCFLConfiguration | null | undefined`: Optional adaptive CFL substep policy. - `densityPrediction?: boolean | undefined`: Whether the transfer predicts density during particle-to-grid work. - `diagnostics?: MPMDiagnosticsOptions | null | undefined`: Optional asynchronous overflow and CFL diagnostics. - `formulation?: MPMFormulation | undefined`: Fused production graph or split reference graph. - `gravity?: Vector3 | undefined`: Acceleration applied in normalized-domain units. - `gridForce?: MPMGridForce | null | undefined`: Caller hook that modifies grid velocity. - `gridSize?: Vector3 | undefined`: Integer dimensions of the normalized-domain transfer grid. - `integrationProfile?: MPMIntegrationProfile | undefined`: Production behavior or strict Three.js r185 comparison behavior. - `material?: MPMMaterialModel | undefined`: Material-owned particle fields and constitutive response. - `maxVelocity?: number | undefined`: Velocity clamp used by the grid update. - `onParticleUpdate?: MPMParticleUpdate | null | undefined`: Caller hook that observes or adjusts the updated particle state. - `p2gMode?: MPMP2GMode | undefined`: Atomic, subgroup, or automatically selected particle-to-grid path. - `packedGridMirror?: boolean | undefined`: Pack the non-atomic grid mirror into half-precision lanes. - `particleForce?: MPMParticleForce | null | undefined`: Caller hook that modifies particle velocity. - `postPasses?: MPMPostPasses | null | undefined`: Caller-owned compute passes appended after the final substep. - `sorting?: MPMSortingOptions | null | undefined`: Optional particle locality sorting policy. - `substeps?: number | undefined`: Minimum fixed substeps per frame. - `workgroupSize?: number | undefined`: Threads requested for particle compute workgroups. ### MPMSolverUniforms Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMSolverUniforms. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSolverUniforms } from "three-blocks/mpm"; interface MPMSolverUniforms ``` **Purpose:** Mutable TSL uniforms shared by the solver kernel graph. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSolverUniforms. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `dt: TSLUniformNode<'float', number>`: Current substep duration in seconds. - `gravity: TSLUniformNode<'vec3', Vector3>`: Normalized-domain gravity vector. - `gridSize: TSLUniformNode<'vec3', Vector3>`: Integer transfer-grid dimensions. - `maxVelocity: TSLUniformNode<'float', number>`: Maximum allowed velocity magnitude. - `particleCount: TSLUniformNode<'uint', number>`: Active particle prefix length. - `time: TSLUniformNode<'float', number>`: Simulation time at the start of the submitted frame. ### MPMSortingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMSortingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMSortingOptions } from "three-blocks/mpm"; interface MPMSortingOptions ``` **Purpose:** Optional spatial binning cadence for particle locality. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMSortingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `blockSize?: number | undefined`: Grid cells grouped along each sorting axis. - `interval?: number | undefined`: Number of frames between sorting passes. ### MPMStepPostPassContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMStepPostPassContext. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMStepPostPassContext } from "three-blocks/mpm"; interface MPMStepPostPassContext ``` **Purpose:** Frame metadata supplied when resolving caller-owned post passes. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMStepPostPassContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `dt: number`: Full frame delta in seconds. - `frame: number`: Zero-based solver frame before the current submission. - `substeps: number`: Number of solver substeps submitted for the frame. ### MPMStepStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/MPMStepStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MPMStepStats } from "three-blocks/mpm"; interface MPMStepStats ``` **Purpose:** Diagnostic description of the most recently submitted solver frame. **Status:** Stable through the curated Material Point Method block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MPMStepStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/mpm. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/mpm Direct example imports: none recorded. - `diagnostics?: MPMDiagnosticsSnapshot | undefined`: Latest available asynchronous counters, when enabled. - `dispatches: number`: Total compute dispatches in the batch. - `formulation: MPMFormulation`: Formulation used to build the pass graph. - `integrationProfile: MPMIntegrationProfile`: Active integration compatibility profile. - `p2gMode: MPMGridContributionMode`: Particle-to-grid implementation selected for the frame. - `particleCount: number`: Active particle prefix length. - `passes: string[]`: Submitted pass names in execution order. - `sorted: boolean`: Whether particle locality sorting ran this frame. - `submissions: number`: Renderer compute submissions used by the step. - `substeps: number`: Solver substeps represented by the batch. ### MSDFFont Kind: class; canonical: https://threejs-blocks.com/docs/api/MSDFFont. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MSDFFont } from "three-blocks/msdf-text"; class MSDFFont ``` **Purpose:** A parsed MSDF font atlas: glyph metrics in em units plus UV rects into the atlas texture. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `ascender: number`: Ascender height above the baseline in em units. - `atlasHeight: number`: Atlas texture height in pixels. - `atlasWidth: number`: Atlas texture width in pixels. - `constructor()`: Creates an empty normalized font record with safe fallback metrics. - `descender: number`: Descender position below the baseline in em units. - `distanceRange: number`: Signed-distance range encoded by the atlas, measured in atlas pixels. - `getGlyph(codePoint: number): MSDFGlyph | null`: Looks up a glyph with fallback to U+FFFD then '?'. Returns null only when the atlas has neither the glyph nor a fallback (e.g. an icon-only atlas). - `getKerning(left: number, right: number): number`: Reads the kerning adjustment for two adjacent Unicode code points. - `glyphs: Map`: Normalized glyph metrics keyed by Unicode code point. - `has(codePoint: number): boolean`: Reports whether the atlas contains a glyph for a Unicode code point. - `kernings: Map`: Kerning adjustments in em units keyed by `left:right` code-point pairs. - `lineHeight: number`: Default line-box height in em units. - `name: string`: Informational font-family name from the source metadata. - `size: number`: Source font size used to generate the atlas, measured in pixels per em. - `underlineThickness: number`: Recommended underline thickness in em units. - `underlineY: number`: Recommended underline position in em units. ### MSDFGlyph Kind: interface; canonical: https://threejs-blocks.com/docs/api/MSDFGlyph. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MSDFGlyph } from "three-blocks/msdf-text"; interface MSDFGlyph ``` **Purpose:** One normalized glyph entry stored by MSDFFont. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MSDFGlyph. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `advance: number`: Horizontal pen advance in em units. - `planeBounds: MSDFRect`: Glyph plane bounds in em units relative to the baseline. - `uvRect: MSDFUVRect`: Glyph rectangle within the companion atlas texture. ### MSDFText Kind: class; canonical: https://threejs-blocks.com/docs/api/MSDFText. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MSDFText } from "three-blocks"; import { MSDFText } from "three-blocks/msdf-text"; class MSDFText extends THREE.Mesh ``` **Purpose:** A text block rendered from a pre-generated MSDF atlas — one instanced quad per glyph, one draw call per text. Layout is synchronous and CPU-cheap (advances + kerning from the font JSON); no runtime SDF generation, no async glyph pipeline. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `get align(): MSDFTextAlign`: Horizontal alignment of lines within the self-layout width. - `set align(value: MSDFTextAlign)`: Horizontal alignment of lines within the self-layout width. - `get anchorX(): MSDFTextAnchorX`: Horizontal origin of the self-laid-out block. - `set anchorX(value: MSDFTextAnchorX)`: Horizontal origin of the self-laid-out block. - `get anchorY(): MSDFTextAnchorY`: Vertical origin of the self-laid-out block. - `set anchorY(value: MSDFTextAnchorY)`: Vertical origin of the self-laid-out block. - `get color(): THREE.Color`: Text color. Mutating the returned Three.js color updates rendering immediately. - `set color(value: THREE.ColorRepresentation)`: Text color. Mutating the returned Three.js color updates rendering immediately. - `constructor(options?: MSDFTextOptions)`: Creates one renderable text mesh and takes ownership of its generated geometry and material. The supplied font metrics and atlas texture remain caller-owned. - `dispose(): void`: Frees the owned GPU geometry and material. The caller-owned atlas texture is not disposed. - `get font(): MSDFFont | null`: Parsed atlas metrics used for subsequent layouts. The caller retains ownership. - `set font(value: MSDFFont | null)`: Parsed atlas metrics used for subsequent layouts. The caller retains ownership. - `get fontSize(): number`: World units per em, or CSS pixels per em in screen-space mode. - `set fontSize(value: number)`: World units per em, or CSS pixels per em in screen-space mode. - `readonly isMSDFText: boolean`: Runtime type guard for MSDF text meshes. - `get layoutInfo(): Readonly`: Read-only dimensions and glyph count from the most recent synchronous layout. - `get letterSpacing(): number`: Additional spacing between adjacent glyphs. - `set letterSpacing(value: number)`: Additional spacing between adjacent glyphs. - `get lineHeight(): number`: Line-box height, or zero to use the font's default line height. - `set lineHeight(value: number)`: Line-box height, or zero to use the font's default line height. - `get maxWidth(): number`: Maximum line width used by self-layout before wrapping. - `set maxWidth(value: number)`: Maximum line width used by self-layout before wrapping. - `onBeforeRender(): void`: Coalesces pending layout changes immediately before Three.js renders the mesh. - `get opacity(): number`: Text opacity in the inclusive range normally used by Three.js materials. - `set opacity(value: number)`: Text opacity in the inclusive range normally used by Three.js materials. - `setLines(lines: readonly MSDFTextLineInput[] | null): void`: Pre-broken lines mode — mirrors externally computed line boxes (e.g. DOM Range rects). Passing null returns to self-layout of `.text`. - `setMap(map: THREE.Texture | null): void`: Binds the atlas texture (normalizing its sampler state for MSDF). - `setScreenOffset(x: number, y: number): void`: screenSpace: places the mesh origin in the viewport (CSS px, y-down top-left origin). - `setViewport(width: number, height: number): void`: screenSpace: the canvas CSS pixel size (share the same values across all texts). - `get text(): string`: Text content for self-layout mode; assigning it leaves pre-broken-lines mode. - `set text(value: unknown)`: Text content for self-layout mode; assigning it leaves pre-broken-lines mode. - `update(): void`: Relayouts the text and rewrites the instance buffers. Runs automatically before rendering when a property changed; call directly to force a synchronous rebuild. - `get weightBias(): number`: Signed fake-weight bias; positive values make glyph strokes appear bolder. - `set weightBias(value: number)`: Signed fake-weight bias; positive values make glyph strokes appear bolder. ### MSDFTextLayoutInfo Kind: interface; canonical: https://threejs-blocks.com/docs/api/MSDFTextLayoutInfo. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MSDFTextLayoutInfo } from "three-blocks/msdf-text"; interface MSDFTextLayoutInfo ``` **Purpose:** Read-only layout statistics from the most recent update. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MSDFTextLayoutInfo. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `glyphCount: number`: Number of drawable glyph instances. - `height: number`: Laid-out height in text units. - `width: number`: Laid-out width in text units. ### MSDFTextLineInput Kind: interface; canonical: https://threejs-blocks.com/docs/api/MSDFTextLineInput. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MSDFTextLineInput } from "three-blocks/msdf-text"; interface MSDFTextLineInput ``` **Purpose:** One pre-broken line supplied by an external layout system. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MSDFTextLineInput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `text: string`: Text content for this line. - `width?: number | undefined`: Optional target width fitted with bounded letter spacing. - `x: number`: Horizontal line origin in text units. - `y: number`: Baseline position in text units, with positive Y pointing up. ### MSDFTextOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/MSDFTextOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MSDFTextOptions } from "three-blocks/msdf-text"; interface MSDFTextOptions ``` **Purpose:** Construction options for MSDFText. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MSDFTextOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `align?: MSDFTextAlign | undefined`: Horizontal alignment within the maximum width. - `anchorX?: MSDFTextAnchorX | undefined`: Horizontal origin for the laid-out block. - `anchorY?: MSDFTextAnchorY | undefined`: Vertical origin for the laid-out block. - `color?: THREE.ColorRepresentation | undefined`: Initial text color. - `font?: MSDFFont | null | undefined`: Parsed metrics for the atlas texture. - `fontSize?: number | undefined`: World units per em, or CSS pixels per em in screen-space mode. - `letterSpacing?: number | undefined`: Additional spacing between adjacent glyphs. - `lineHeight?: number | undefined`: Line-box height, or zero to use the font's default. - `lines?: readonly MSDFTextLineInput[] | null | undefined`: Pre-broken lines that override self-layout while non-null. - `map?: THREE.Texture | null | undefined`: MSDF atlas texture. The caller retains ownership and disposes it. - `maxWidth?: number | undefined`: Maximum line width used by self-layout. - `opacity?: number | undefined`: Initial text opacity. - `pixelSnap?: boolean | undefined`: screenSpace only: snap glyph origins to physical pixels (default true). Disable for smoothly animated text. - `screenSpace?: boolean | undefined`: Whether positions and sizes use CSS-pixel viewport coordinates. - `text?: string | undefined`: Content for self-layout mode. Newlines are supported. ### MaybePromise Kind: type; canonical: https://threejs-blocks.com/docs/api/MaybePromise. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MaybePromise } from "three-blocks/hmr"; type MaybePromise = TValue | PromiseLike ``` **Purpose:** Declares MaybePromise as a public type. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MaybePromise. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### MeshTransmissionDitherAnchor Kind: type; canonical: https://threejs-blocks.com/docs/api/MeshTransmissionDitherAnchor. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MeshTransmissionDitherAnchor } from "three-blocks/transmission"; type MeshTransmissionDitherAnchor = MeshTransmissionDitherAnchorImplementation ``` **Purpose:** Coordinate domain used to anchor stochastic transmission sampling. **Status:** Stable through the curated Transmission block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MeshTransmissionDitherAnchor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/transmission. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/transmission Direct example imports: none recorded. ### MeshTransmissionNodeMaterial Kind: variable; canonical: https://threejs-blocks.com/docs/api/MeshTransmissionNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { MeshTransmissionNodeMaterial } from "three-blocks/transmission"; const MeshTransmissionNodeMaterial: MeshTransmissionNodeMaterialConstructor ``` **Purpose:** Intentional stable surface for the transmission material. **Status:** Stable through the curated Transmission block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/transmission. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/transmission Direct example imports: https://threejs-blocks.com/examples/webgpu_baked_motion_rotation, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_material_transmission. - `anisotropicBlur: number`: Directional blur strength along the refraction flow. - `backdropDistance: number`: Assumed world-space distance from the exit surface to the sampled backdrop. - `blurScale: number`: Artistic multiplier applied to the physically scaled blur footprint. - `chromaticAberration: number`: Artistic per-channel dispersion strength. - `new (options?: MeshTransmissionNodeMaterialOptions): MeshTransmissionNodeMaterial`: Create a physical transmission material with optional stable transmission controls. - `dispose(): void`: Release Three.js material resources. The operation is safe to repeat; it does not dispose a custom viewport buffer supplied by the caller. - `distortion: number`: Noise displacement applied to the refraction normal. - `distortionScale: number`: World-space scale of the distortion noise. - `ditherAnchor: MeshTransmissionDitherAnchor`: Dither coordinate domain; changing this recompiles the material. - `ditherScale: number`: Tiling frequency of the stochastic sampling pattern. - `ditherStrength: number`: Stochastic sampling jitter strength. - `edgeFade: number`: Normalized viewport-border width used to fade refraction offsets. - `readonly isMeshTransmissionNodeMaterial: true`: Runtime type guard that is always `true` for this material. - `refractionMode: MeshTransmissionRefractionMode`: Post-exit ray model; changing this recompiles the material. - `samples: number`: Stochastic gather taps per colour channel; changing this recompiles the material. - `surfaceDistortion: number`: Noise displacement applied to the shading normal. - `temporalDistortion: number`: Animation strength for time-varying distortion. - `time: number`: Offset added to the internal clock used by temporal distortion. - `viewportBuffer: MeshTransmissionViewportBufferNode | null`: Borrowed viewport source sampled by the refraction graph. Assigning `null` restores the package-owned shared viewport snapshot; changing the source recompiles the material. ### MeshTransmissionNodeMaterialOptions Kind: type; canonical: https://threejs-blocks.com/docs/api/MeshTransmissionNodeMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MeshTransmissionNodeMaterialOptions } from "three-blocks/transmission"; type MeshTransmissionNodeMaterialOptions = MeshTransmissionNodeMaterialParameters ``` **Purpose:** Physical-material parameters plus the intentional transmission controls accepted at construction. A custom viewport buffer is borrowed and is never disposed by the material. **Status:** Stable through the curated Transmission block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MeshTransmissionNodeMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/transmission. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/transmission Direct example imports: none recorded. ### MeshTransmissionRefractionMode Kind: type; canonical: https://threejs-blocks.com/docs/api/MeshTransmissionRefractionMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MeshTransmissionRefractionMode } from "three-blocks/transmission"; type MeshTransmissionRefractionMode = MeshTransmissionRefractionModeImplementation ``` **Purpose:** Post-exit refraction model used when the backdrop has a non-zero distance. **Status:** Stable through the curated Transmission block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MeshTransmissionRefractionMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/transmission. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/transmission Direct example imports: none recorded. ### MeshTransmissionViewportBufferNode Kind: type; canonical: https://threejs-blocks.com/docs/api/MeshTransmissionViewportBufferNode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { MeshTransmissionViewportBufferNode } from "three-blocks/transmission"; type MeshTransmissionViewportBufferNode = MeshTransmissionViewportBufferNodeImplementation ``` **Purpose:** Sampleable mip-aware TSL source accepted as a custom transmission backdrop. **Status:** Stable through the curated Transmission block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MeshTransmissionViewportBufferNode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/transmission. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/transmission Direct example imports: none recorded. ### MessageEndpoint Kind: interface; canonical: https://threejs-blocks.com/docs/api/MessageEndpoint. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MessageEndpoint } from "three-blocks/worker"; interface MessageEndpoint ``` **Purpose:** The DOM-free subset shared by Worker, MessagePort, and Node MessagePort adapters. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: start and close. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `addEventListener(type: 'message', listener: MessageEndpointListener): void` - `close?(): void` - `postMessage(message: unknown, transfer?: readonly object[]): void` - `removeEventListener(type: 'message', listener: MessageEndpointListener): void` - `start?(): void` ### MessageEndpointListener Kind: type; canonical: https://threejs-blocks.com/docs/api/MessageEndpointListener. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MessageEndpointListener } from "three-blocks/worker"; type MessageEndpointListener = (event: MessageEventLike) => void ``` **Purpose:** Declares MessageEndpointListener as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MessageEndpointListener. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### MessageEndpointSource Kind: type; canonical: https://threejs-blocks.com/docs/api/MessageEndpointSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MessageEndpointSource } from "three-blocks/worker"; type MessageEndpointSource = MessageEndpoint | BrowserMessageEndpoint ``` **Purpose:** Declares MessageEndpointSource as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MessageEndpointSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### MessageEventLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/MessageEventLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MessageEventLike } from "three-blocks/worker"; interface MessageEventLike ``` **Purpose:** Declares MessageEventLike as a public interface. It is exported from three-blocks/worker. Its declared surface covers data. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MessageEventLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly data: T` ### MissingGlyphDiagnostic Kind: interface; canonical: https://threejs-blocks.com/docs/api/MissingGlyphDiagnostic. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { MissingGlyphDiagnostic } from "three-blocks/text"; interface MissingGlyphDiagnostic ``` **Purpose:** Declares MissingGlyphDiagnostic as a public interface. It is exported from three-blocks/text. Its declared surface covers code, codePoints, command, and font. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for MissingGlyphDiagnostic. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code: 'missing-glyphs'` - `readonly codePoints: readonly number[]` - `readonly command: string` - `readonly font: string` ### NamedAssetHandles Kind: type; canonical: https://threejs-blocks.com/docs/api/NamedAssetHandles. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { NamedAssetHandles } from "three-blocks/assets"; type NamedAssetHandles = {readonly [TName in keyof TResult]: AssetHandle;} ``` **Purpose:** Declares NamedAssetHandles as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for NamedAssetHandles. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### NamedAssetPromises Kind: type; canonical: https://threejs-blocks.com/docs/api/NamedAssetPromises. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { NamedAssetPromises } from "three-blocks/assets"; type NamedAssetPromises = {readonly [TName in keyof TResult]: Promise;} ``` **Purpose:** Declares NamedAssetPromises as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for NamedAssetPromises. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### NodeAddress Kind: type; canonical: https://threejs-blocks.com/docs/api/NodeAddress. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { NodeAddress } from "three-blocks/shaders"; type NodeAddress = {readonly k: 'anchor'; readonly key?: string; readonly slot: string; readonly path: readonly number[];} | {readonly k: 'container'; readonly key: string; readonly path: readonly ShaderPathSegment[];} | {readonly k: 'owned'; readonly owner: NodeAddress; readonly path: readonly ShaderPathSegment[]; readonly prime?: 'reference';} | {readonly k: 'tsl'; readonly name: string;} | {readonly k: 'lightNode'; readonly light: number; /** Scene traversal fallback for render paths whose built LightsNode is empty. */ readonly sceneLight?: number;} | {readonly k: 'lightUniform'; readonly fn: 'lightPosition' | 'lightTargetPosition' | 'lightViewPosition' | 'lightShadowMatrix' | 'spotLightMap' | 'shadowCameraNear' | 'shadowCameraFar' | 'shadowBias' | 'shadowIntensity' | 'shadowNormalBias' | 'shadowRadius' | 'shadowBlurSamples' | 'shadowMapSize'; readonly light: number; /** Scene traversal fallback for render paths whose built LightsNode is empty. */ readonly sceneLight?: number;} | {readonly k: 'materialCache'; readonly property: string; readonly type: string | null;} | {readonly k: 'sceneEnv';} | {readonly k: 'namedRenderUniform'; readonly name: string;} | {readonly k: 'reference'; readonly property: string; readonly uniformType: string; readonly count?: number; readonly object?: {readonly container: string; readonly path: readonly ShaderPathSegment[];}; readonly group?: string; readonly name?: string;} | {readonly k: 'inputNode'; readonly nodeClass: string; readonly value: {readonly container: string; readonly path: readonly ShaderPathSegment[];}; readonly access?: string | null; readonly uniformType?: string | null; readonly group?: string; /** Application-set node name; deterministic buffer labels derive from it. */ readonly name?: string; /** Whether TextureNode used a depth-comparison sampler in captured WGSL. */ readonly comparison?: boolean; /** StorageBufferNode reconstruction metadata (ignored by other input recipes). */ readonly bufferCount?: number; readonly atomic?: boolean; readonly pbo?: boolean; /** BufferAttributeNode reconstruction metadata (ignored by other recipes). */ readonly stride?: number; readonly offset?: number; readonly usage?: number; readonly instanced?: boolean; readonly n?: number;} | {readonly k: 'inputValue'; readonly nodeClass: string; readonly json: SerializedShaderValue; readonly access?: string | null; readonly uniformType?: string | null; readonly group?: string; /** Application-set node name; deterministic buffer labels derive from it. */ readonly name?: string; readonly comparison?: boolean; readonly bufferCount?: number; readonly atomic?: boolean; readonly pbo?: boolean; readonly stride?: number; readonly offset?: number; readonly usage?: number; readonly instanced?: boolean; readonly n?: number;} | {readonly k: 'recipe'; readonly id: string; readonly version: typeof SHADER_RECIPE_SCHEMA_VERSION; readonly input?: SerializedShaderValue;} ``` **Purpose:** A stable path to a live node. Recipe-backed variants are resolved exclusively by the active, version-gated Three.js compatibility adapter. Typed-array payloads inside `inputValue` records use little-endian base64 `data` strings. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for NodeAddress. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### OAV_MANIFEST_TYPE Kind: variable; canonical: https://threejs-blocks.com/docs/api/OAV_MANIFEST_TYPE. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { OAV_MANIFEST_TYPE } from "three-blocks/experimental/object-animation-video"; const OAV_MANIFEST_TYPE: "utsubo-oav" ``` **Purpose:** Persisted Object Animation Video package discriminator. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for OAV_MANIFEST_TYPE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### OAV_MANIFEST_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/OAV_MANIFEST_VERSION. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { OAV_MANIFEST_VERSION } from "three-blocks/experimental/object-animation-video"; const OAV_MANIFEST_VERSION: 2 ``` **Purpose:** Second public Object Animation Video manifest schema: transforms travel as one block-indexed UTSBM `.utsbm` asset, fetched once and streamed progressively. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for OAV_MANIFEST_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideo Kind: variable; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideo. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { ObjectAnimationVideo } from "three-blocks/experimental/object-animation-video"; const ObjectAnimationVideo: ObjectAnimationVideoConstructor ``` **Purpose:** Runtime-only Object Animation Video playback facade. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, pause, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect. - `bind(root: THREE.Object3D, options?: ObjectAnimationVideoBindOptions): ObjectAnimationVideoBindResult`: Bind every manifest object to a same-named descendant beneath a borrowed root. - `bindBatchedMesh(target: ObjectAnimationVideoInstanceTarget, mapping?: readonly ObjectAnimationVideoInstanceMapping[] | null): ObjectAnimationVideoInstanceBinding[]`: Bind manifest objects to slots on a borrowed instanced or batched target. - `bindObject(indexOrName: ObjectAnimationVideoObjectSelector, target: THREE.Object3D): ObjectAnimationVideoObjectBinding`: Bind one authored object index or name to a borrowed Three.js object. - `new (manifest: unknown, options: ObjectAnimationVideoOptions): ObjectAnimationVideo` - `dispose(): void`: Release the decoder, frame cache, and internal texture. Idempotent; all Object3D bindings are restored and borrowed scene/instance objects are never disposed. - `readonly duration: number`: Clip duration in seconds. - `readonly firstFrame: Promise`: Resolves after the first decoded frame is applied, or with `null` after early disposal. - `getDiagnostics(): Readonly`: Inspect exact decoding and bounded numerical residency. - `getMatrixAt(indexOrName: ObjectAnimationVideoObjectSelector, target?: THREE.Matrix4): THREE.Matrix4`: Copy the current interpolated matrix for a custom integration. - `loop: boolean`: Whether playback wraps after the final frame. - `readonly manifest: ObjectAnimationVideoManifest`: Validated immutable manifest used by playback and object-name lookup. - `pause(): this`: Pause playback while retaining the currently applied matrices. - `play(): this`: Resume playback-time advancement. - `playbackSpeed: number`: Playback time multiplier. - `readonly playing: boolean`: Whether `update()` advances playback time. - `readonly ready: Promise`: Resolves after manifest validation and UTSBM decoder configuration. Rejects on invalid input, a missing track asset, fetch failure, or failed integrity checks. - `resume(): Promise`: Reconfigure released decoder resources and resume frame requests. - `setFrame(frame: number): this`: Seek to an authored frame index. - `setTime(seconds: number): this`: Seek to a time in seconds and apply the best decoded interpolation immediately. - `suspend(): void`: Release active decoder resources while retaining the displayed matrices, bindings, texture, and playback position. - `readonly time: number`: Current playback time in seconds. - `unbind(binding: ObjectAnimationVideoBinding, options?: ObjectAnimationVideoUnbindOptions): boolean`: Remove one binding, restoring Object3D state by default. - `update(deltaSeconds: number): this`: Advance playback and apply decoded matrices. Call once after input/control updates and before Three.js updates world matrices and renders the frame. ### ObjectAnimationVideoBindOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoBindOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoBindOptions } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoBindOptions ``` **Purpose:** Options for binding same-named descendants beneath a root. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoBindOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `strict?: boolean`: Throw instead of returning missing names when any manifest object is absent. ### ObjectAnimationVideoBindResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoBindResult. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoBindResult } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoBindResult ``` **Purpose:** Result of binding all same-named descendants beneath a Three.js root. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoBindResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `bound: number`: Number of manifest objects successfully bound. - `missing: string[]`: Authored object names not found beneath the supplied root. ### ObjectAnimationVideoBinding Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoBinding. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoBinding } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoBinding = ObjectAnimationVideoObjectBinding | ObjectAnimationVideoInstanceBinding ``` **Purpose:** Binding handle accepted by ObjectAnimationVideo.unbind. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoBinding. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoDecodeEvent Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoDecodeEvent. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoDecodeEvent } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoDecodeEvent ``` **Purpose:** Notification emitted after an encoded frame is decoded and cached. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoDecodeEvent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `frame: number`: Decoded frame index. ### ObjectAnimationVideoDiagnostics Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoDiagnostics. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoDiagnostics } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoDiagnostics = ObjectAnimationVideoDiagnosticsImplementation ``` **Purpose:** Snapshot of OAV exact decoding and bounded-residency counters. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoDiagnostics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoErrorEvent Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoErrorEvent. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoErrorEvent } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoErrorEvent ``` **Purpose:** Fatal indexed decode notification. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoErrorEvent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `error: unknown`: Range, integrity, or decode failure. ### ObjectAnimationVideoEventMap Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoEventMap. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoEventMap } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoEventMap ``` **Purpose:** Typed Three.js events emitted during OAV decoding and playback. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoEventMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `decode: ObjectAnimationVideoDecodeEvent`: Completed frame decode event. - `error: ObjectAnimationVideoErrorEvent`: Fatal decode event. - `frame: ObjectAnimationVideoFrameEvent`: Applied interpolated frame event. ### ObjectAnimationVideoFetch Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoFetch. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoFetch } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoFetch = (input: string, init?: RequestInit) => Promise ``` **Purpose:** Injectable network function used by ObjectAnimationVideo.load. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoFetch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoFetchResponse Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoFetchResponse. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoFetchResponse } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoFetchResponse ``` **Purpose:** Minimal fetch response consumed while loading an OAV manifest and its block-indexed UTSBM track asset. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoFetchResponse. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `arrayBuffer?: () => Promise`: Read one whole binary block-asset response. - `json(): Promise`: Read and decode the manifest response. - `readonly ok: boolean`: Whether the response completed with a successful HTTP status. - `readonly status: number`: Numeric HTTP status used in load failures. ### ObjectAnimationVideoFileValue Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoFileValue. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoFileValue } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoFileValue = ArrayBuffer | ArrayBufferView ``` **Purpose:** Accepted byte containers in an in-memory OAV package. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoFileValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoFiles Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoFiles. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoFiles } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoFiles = Map | Record ``` **Purpose:** Manifest-relative in-memory package consumed by `loadFromFiles()`. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoFiles. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoFrameEvent Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoFrameEvent. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoFrameEvent } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoFrameEvent ``` **Purpose:** Notification emitted after interpolated matrices are applied to bindings. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoFrameEvent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `alpha: number`: Interpolation amount between the lower and upper frames. - `frame: number`: Fractional sampled frame. - `lowerFrame: number`: Lower decoded interpolation frame. - `upperFrame: number`: Upper decoded interpolation frame. ### ObjectAnimationVideoInstanceBinding Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoInstanceBinding. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoInstanceBinding } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoInstanceBinding ``` **Purpose:** Removable binding to one slot in an instanced or batched target. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoInstanceBinding. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `readonly instanceIndex: number`: Destination instance slot. - `readonly kind: 'instance'`: Binding discriminator. - `readonly target: ObjectAnimationVideoInstanceTarget`: Borrowed instance target receiving decoded matrices. ### ObjectAnimationVideoInstanceMapping Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoInstanceMapping. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoInstanceMapping } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoInstanceMapping = number | ({objectIndex?: ObjectAnimationVideoObjectSelector; object?: ObjectAnimationVideoObjectSelector;} & ({instanceIndex: number; instance?: number;} | {instanceIndex?: never; instance: number;})) ``` **Purpose:** Compact destination index or explicit manifest-object-to-instance mapping accepted by ObjectAnimationVideo.bindBatchedMesh. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoInstanceMapping. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoInstanceTarget Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoInstanceTarget. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoInstanceTarget } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoInstanceTarget ``` **Purpose:** Minimal caller-owned instancing target accepted by `bindBatchedMesh()`. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoInstanceTarget. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `readonly instanceMatrix?: {needsUpdate: boolean;}`: Optional Three.js update flag set after an instance batch is applied. - `setMatrixAt(index: number, matrix: THREE.Matrix4): unknown`: Apply one decoded transform to an instance slot. ### ObjectAnimationVideoLoadOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoLoadOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoLoadOptions } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoLoadOptions extends ObjectAnimationVideoPlaybackOptions ``` **Purpose:** Network-load options for ObjectAnimationVideo.load. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoLoadOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `fetchImpl?: ObjectAnimationVideoFetch`: Optional fetch implementation used for the manifest and the block-indexed UTSBM track asset. ### ObjectAnimationVideoManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoManifest } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoManifest = Readonly ``` **Purpose:** Validated Object Animation Video package manifest. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoObjectBinding Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoObjectBinding. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoObjectBinding } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoObjectBinding ``` **Purpose:** Removable binding to a caller-owned Three.js object. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoObjectBinding. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `readonly kind: 'object'`: Binding discriminator. - `readonly matrix: THREE.Matrix4`: Original local matrix retained for restoration. - `readonly matrixAutoUpdate: boolean`: Original automatic-matrix setting retained for restoration. - `readonly target: THREE.Object3D`: Borrowed object receiving decoded matrices. ### ObjectAnimationVideoObjectSelector Kind: type; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoObjectSelector. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoObjectSelector } from "three-blocks/experimental/object-animation-video"; type ObjectAnimationVideoObjectSelector = number | string ``` **Purpose:** Manifest object index or stable authored name. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoObjectSelector. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### ObjectAnimationVideoOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoOptions } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoOptions extends ObjectAnimationVideoPlaybackOptions ``` **Purpose:** Direct-construction options: how the block-indexed UTSBM track asset referenced by the manifest loads — one fetch per track, consumed progressively. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `fetchImpl?: ObjectAnimationVideoFetch`: Fetch implementation used for the block-indexed UTSBM track asset. - `resolveFile?: (file: string) => string`: Manifest-relative path resolver used by direct construction. ### ObjectAnimationVideoPlaybackOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoPlaybackOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoPlaybackOptions } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoPlaybackOptions ``` **Purpose:** Playback controls shared by network, in-memory, and direct construction. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoPlaybackOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `loop?: boolean`: Whether playback wraps after the final frame. - `meshoptDecoder?: MeshoptVertexDecoderLike`: Meshopt vertex decoder for the UTSBM transform track — pass `MeshoptDecoder` from `three/addons/libs/meshopt_decoder.module.js` (the same module `GLTFLoader` uses). - `play?: boolean`: Whether the clip begins in the playing state. - `playbackSpeed?: number`: Playback time multiplier. ### ObjectAnimationVideoUnbindOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObjectAnimationVideoUnbindOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { ObjectAnimationVideoUnbindOptions } from "three-blocks/experimental/object-animation-video"; interface ObjectAnimationVideoUnbindOptions ``` **Purpose:** Options for removing a previously returned binding. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObjectAnimationVideoUnbindOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. - `restore?: boolean`: Restore an Object3D's original matrix and auto-update setting. ### ObserveThreeBlocksTslBuildsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ObserveThreeBlocksTslBuildsOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ObserveThreeBlocksTslBuildsOptions } from "three-blocks/devtools"; interface ObserveThreeBlocksTslBuildsOptions ``` **Purpose:** Declares ObserveThreeBlocksTslBuildsOptions as a public interface. It is exported from three-blocks/devtools. Its declared surface covers onSnapshot. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ObserveThreeBlocksTslBuildsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly onSnapshot?: (snapshot: ThreeBlocksTslBuildSnapshot) => void` ### PBF Kind: variable; canonical: https://threejs-blocks.com/docs/api/PBF. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { PBF } from "three-blocks"; import { PBF } from "three-blocks/pbf"; const PBF: PBFConstructor ``` **Purpose:** Stable declaration-facing façade for the Position-Based Fluids engine. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: https://threejs-blocks.com/examples/webgpu_material_transmission, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `new (options?: PBFOptions): PBF`: Construct a PBF engine and allocate its owned GPU storage. Throws: Error — If calibration, initial layout, or GPU storage construction fails; TypeError — If an external initial-position source is incompatible. - `dispose(): void`: Release engine-owned grids, storage resources, compute passes, and GUI bindings. Caller-owned renderers, domain objects, initial-position sources, and render assets are untouched. Repeated host teardown may call this method safely; do not step after disposal. - `getLastMetrics(): Readonly | null`: Return the latest immutable metric snapshot, or `null` before a requested readback completes. - `getStats(): Readonly`: Return lightweight synchronous state without exposing live GPU resources. - `readonly particleCount: number`: Number of live particles advanced by each step. - `requestMetricsReadback(): this`: Request one asynchronous diagnostic readback after the next completed step. Readback can stall the GPU; it is never performed unless explicitly requested. - `reset(renderer: Renderer, options?: PBFResetOptions): Promise`: Replace live particle positions with a deterministic generated layout. Await any active step first and call before rendering the next frame. - `setDomainDimensions(dimensions: Vector3): this`: Resize the axis-aligned domain and synchronize neighbor acceleration. Call between steps. - `setDomainFromObject(object: Object3D, options?: PBFDomainBindingOptions): this`: Bind the simulation domain to a caller-owned Three.js object. The object is observed but never disposed by the simulation. - `setMass(value: number): this`: Set particle mass and refresh automatic density calibration when enabled. Call between frames before the next solver step. - `setRestDensity(value: number | null | undefined): this`: Set target density, or pass `null` to restore calibrated automatic density. Call between frames before the next solver step. - `setSmoothingRadius(radius: number): this`: Change the density-kernel radius and rebuild dependent coefficients. Call between frames; active neighbor acceleration is synchronized automatically. - `setSpatialGridEnabled(enabled: boolean): this`: Enable or disable engine-owned neighbor-grid acceleration between frames. - `setTimeStepOptions(options?: PBFTimeStepOptions): this`: Update fixed-step scheduling between frames. Changes apply to the next PBF.step call. - `step(renderer: Renderer, deltaTime?: number | undefined): Promise`: Advance GPU state for one host frame. Update controls and bound objects first, await this method, then render. The first call may initialize the renderer and copy initial positions. ### PBFArtificialPressureOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFArtificialPressureOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFArtificialPressureOptions } from "three-blocks/pbf"; interface PBFArtificialPressureOptions ``` **Purpose:** Artificial-pressure controls used to prevent tensile clumping. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFArtificialPressureOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `exponent?: number | undefined`: Exponent controlling how quickly the correction grows at close range. - `strength?: number | undefined`: Magnitude of the corrective pressure term. ### PBFCalibrationMode Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFCalibrationMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFCalibrationMode } from "three-blocks/pbf"; type PBFCalibrationMode = 'manual' | 'particle-volume' | 'self-kernel' | 'discrete-lattice' ``` **Purpose:** Supported calibration strategies for particle spacing, mass, and kernel radius. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFCalibrationMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFCalibrationSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFCalibrationSnapshot. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFCalibrationSnapshot } from "three-blocks/pbf"; interface PBFCalibrationSnapshot ``` **Purpose:** Read-only calibration result selected during construction. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFCalibrationSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `readonly dimension: 2 | 3`: Resolved simulation dimensionality. - `readonly expectedNeighborCount: number`: Expected neighbors in the reference lattice. - `readonly mode: PBFCalibrationMode`: Calibration strategy that produced the snapshot. - `readonly neighborQuality: 'low' | 'useful'`: Coarse warning tier for neighbor support. - `readonly particleMass: number`: Resolved particle mass. - `readonly particleRadius: number`: Resolved collision radius. - `readonly referenceDensity: number`: Density reproduced by the reference lattice. - `readonly referenceDensityError: number`: Relative reference-lattice density error. - `readonly restDensity: number`: Resolved target rest density. - `readonly smoothingRadius: number`: Resolved kernel radius. - `readonly smoothingRadiusRatio: number`: Kernel radius divided by particle spacing. - `readonly spacing: number`: Resolved rest spacing. ### PBFComponents Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFComponents. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFComponents } from "three-blocks/pbf"; type PBFComponents = number[] | PBFVectorComponents ``` **Purpose:** Compact vector input accepted by PBF configuration sections. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFComponents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFDiagnosticsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFDiagnosticsOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFDiagnosticsOptions } from "three-blocks/pbf"; interface PBFDiagnosticsOptions ``` **Purpose:** Opt-in diagnostic configuration retained by the metrics subsystem. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFDiagnosticsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `enabled?: boolean | undefined`: Whether the host intends to collect diagnostic snapshots. ### PBFDimension Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFDimension. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFDimension } from "three-blocks/pbf"; type PBFDimension = 2 | 3 | '2d' | '3d' ``` **Purpose:** Dimensionality accepted by nested particle configuration. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFDimension. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFDomainBindingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFDomainBindingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFDomainBindingOptions } from "three-blocks/pbf"; interface PBFDomainBindingOptions ``` **Purpose:** Options for binding the simulation domain to a Three.js object's bounds. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFDomainBindingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `autoUpdate?: boolean | undefined`: Whether object transforms are refreshed before every solver step. - `padding?: number | Vector3 | undefined`: Padding added around the object's local bounds. - `simulationScale?: number | Vector3 | null | undefined`: Optional simulation-to-object scale override. ### PBFDomainOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFDomainOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFDomainOptions } from "three-blocks/pbf"; interface PBFDomainOptions ``` **Purpose:** Axis-aligned domain and boundary-response configuration. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFDomainOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `dimensions?: PBFComponents | Vector3 | undefined`: Domain dimensions expressed as components or a Three.js `Vector3`. - `friction?: number | undefined`: Tangential damping applied at boundaries. - `particleRadiusOffset?: boolean | undefined`: Whether particle radius is included when projecting against box boundaries. - `restitution?: number | undefined`: Normal velocity retained after a boundary collision, from `0` to `1`. ### PBFInitialPositions Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFInitialPositions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFInitialPositions } from "three-blocks/pbf"; type PBFInitialPositions = StorageBufferAttribute | StorageInstancedBufferAttribute ``` **Purpose:** GPU storage accepted as an initial PBF particle-position source. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFInitialPositions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFInitializationMode Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFInitializationMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFInitializationMode } from "three-blocks/pbf"; type PBFInitializationMode = 'block-lattice' | 'block-jittered-lattice' | 'sphere-lattice' | 'random-domain' ``` **Purpose:** Deterministic CPU layout used when no initial GPU position source is supplied. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFInitializationMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFInitializationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFInitializationOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFInitializationOptions } from "three-blocks/pbf"; interface PBFInitializationOptions ``` **Purpose:** Deterministic initial particle-layout configuration. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFInitializationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `fill?: PBFComponents | undefined`: Fractional domain fill per axis. - `jitter?: number | undefined`: Random displacement as a fraction of particle spacing. - `mode?: PBFInitializationMode | undefined`: Shape and sampling policy used to generate positions. - `seed?: number | undefined`: Seed used by deterministic layout jitter. ### PBFMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFMaterialOptions } from "three-blocks/pbf"; interface PBFMaterialOptions ``` **Purpose:** Physical material configuration resolved when constructing a PBF simulation. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `pbf?: PBFSolverMaterialOptions | undefined`: PBF-specific material recommendations. - `preset?: PBFMaterialPreset | undefined`: Named baseline whose remaining fields may be overridden below. - `restDensity?: number | undefined`: Target rest density in simulation mass units. - `surfaceTension?: number | undefined`: Surface-tension recommendation retained in the material snapshot. - `viscosity?: number | undefined`: Dynamic-viscosity recommendation used by the preset system. ### PBFMaterialPreset Kind: type; canonical: https://threejs-blocks.com/docs/api/PBFMaterialPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFMaterialPreset } from "three-blocks/pbf"; type PBFMaterialPreset = 'water' | 'viscousLiquid' | 'gelLike' | 'custom' ``` **Purpose:** Outcome-oriented material presets understood by the fluid configuration normalizer. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFMaterialPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. ### PBFMetricSummary Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFMetricSummary. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFMetricSummary } from "three-blocks/pbf"; interface PBFMetricSummary ``` **Purpose:** Aggregate minimum, mean, and maximum for a sampled metric. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFMetricSummary. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `readonly maximum: number`: Largest sampled value. - `readonly mean: number`: Arithmetic mean across live particles. - `readonly minimum: number`: Smallest sampled value. ### PBFMetrics Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFMetrics. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFMetrics } from "three-blocks/pbf"; interface PBFMetrics ``` **Purpose:** Read-only, opt-in PBF diagnostic snapshot produced after a requested step. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFMetrics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `readonly boundaries: Readonly<{/** Projected particle count when supplied by an active boundary provider. */ projectedParticles: number | null; /** Maximum measured boundary penetration when available. */ maximumPenetration: number | null; /** Number of particle pairs closer than the overlap threshold. */ overlapPairs: number;}>`: Boundary and overlap diagnostics available without exposing live buffers. - `readonly density: Readonly<{/** Mean ratio of measured density to rest density. */ meanRatio: number; /** Root-mean-square density error. */ rmsError: number; /** Largest measured density ratio. */ maximumRatio: number; /** Largest positive density error. */ maximumPositiveError: number;}>`: Density error relative to configured rest density. - `readonly neighbors: Readonly`: Neighbor count distribution over live particles. - `readonly solver: Readonly<{/** Stable solver identifier. */ type: 'pbf'; /** Optional pressure-acceleration magnitude summary. */ pressureAcceleration?: Readonly | undefined; /** Optional viscosity-acceleration magnitude summary. */ viscosityAcceleration?: Readonly | undefined;}>`: Solver-specific diagnostic summaries. - `readonly velocity: Readonly<{/** Largest sampled speed. */ maximum: number; /** Mean sampled speed. */ mean: number;}>`: Particle-speed distribution for the sampled frame. ### PBFNeighborOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFNeighborOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFNeighborOptions } from "three-blocks/pbf"; interface PBFNeighborOptions ``` **Purpose:** Neighbor-acceleration policy selected at construction. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFNeighborOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `buildAlgorithm?: 'auto' | 'atomic' | 'sort' | undefined`: Grid build strategy; `"auto"` selects a renderer-appropriate implementation. - `enabled?: boolean | undefined`: Whether to build and query a spatial neighbor grid. - `lookupAlgorithm?: 'global' | 'workgroup' | undefined`: Neighbor lookup strategy used by solver passes. ### PBFOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFOptions } from "three-blocks/pbf"; interface PBFOptions ``` **Purpose:** Stable PBF construction options. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `boundaryDensitySupport?: boolean | undefined`: Whether supported external boundaries contribute to density constraints. - `calibrationMode?: PBFCalibrationMode | undefined`: Top-level calibration strategy; prefer `particles.calibrationMode`. - `count?: number | undefined`: Top-level flat particle count; prefer `particles.count`. - `debug?: boolean | undefined`: Whether optional diagnostics are collected. - `diagnostics?: PBFDiagnosticsOptions | null | undefined`: Opt-in diagnostic behavior. - `domain?: PBFDomainOptions | null | undefined`: Simulation domain and boundary response. - `domainDimensions?: Vector3 | PBFComponents | undefined`: Top-level domain dimensions; prefer `domain.dimensions`. - `fixedTimeStep?: number | null | undefined`: Top-level fixed interval; prefer `timeStep.fixedDelta`. - `friction?: number | undefined`: Top-level boundary friction; prefer `domain.friction`. - `gravity?: Vector3 | undefined`: Constant world-space acceleration applied to every particle. - `h?: number | undefined`: Top-level smoothing radius; prefer `particles.smoothingRadius`. - `initialPositions?: PBFInitialPositions | null | undefined`: Caller-owned GPU positions copied into engine storage on first use. - `initialization?: PBFInitializationOptions | null | undefined`: Deterministic initial layout when `initialPositions` is omitted. - `is3D?: boolean | undefined`: Top-level dimensionality switch; prefer `particles.dimension`. - `mass?: number | undefined`: Top-level particle mass; prefer `particles.mass`. - `material?: PBFMaterialOptions | null | undefined`: Physical material preset and overrides. - `maxFrameDelta?: number | undefined`: Top-level host-delta cap; prefer `timeStep.maxFrameDelta`. - `maxSpeed?: number | undefined`: Maximum particle speed used to clamp divergent updates. - `maxSubsteps?: number | undefined`: Top-level substep cap; prefer `timeStep.maxSubsteps`. - `neighbors?: PBFNeighborOptions | null | undefined`: Neighbor-acceleration policy. - `particleRadius?: number | null | undefined`: Top-level collision radius; prefer `particles.particleRadius`. - `particles?: PBFParticlesOptions | null | undefined`: Calibrated particle population and layout. - `pressureStiffness?: number | undefined`: Pressure scale used by compatibility force outputs. - `restDensity?: number | null | undefined`: Top-level rest density; `null` enables calibration. - `restitution?: number | undefined`: Top-level boundary restitution; prefer `domain.restitution`. - `scaleKernelWithDomain?: boolean | undefined`: Whether kernel radius follows object-domain scale changes. - `scatterZeroInitialPositions?: boolean | undefined`: Whether zero-valued external positions are scattered during initialization. - `solverIterations?: number | undefined`: Top-level projection count; prefer `solverOptions.iterations`. - `solverOptions?: PBFSolverOptions | null | undefined`: Accuracy and post-projection velocity controls. - `spacing?: number | null | undefined`: Top-level rest spacing; prefer `particles.spacing`. - `timeScale?: number | undefined`: Top-level speed multiplier; prefer `timeStep.timeScale`. - `timeStep?: PBFTimeStepOptions | null | undefined`: Fixed-step scheduling policy. - `useDirection?: boolean | undefined`: Whether internal render integration computes smoothed directions. - `useMatrices?: boolean | undefined`: Whether internal render integration computes instance transforms. - `useSpatialGrid?: boolean | undefined`: Top-level neighbor-grid toggle; prefer `neighbors.enabled`. - `viscosityMu?: number | undefined`: Viscosity scale used by compatibility force outputs. - `vorticityConfinement?: number | undefined`: Top-level vorticity strength; prefer `solverOptions.vorticityConfinement`. - `xsphViscosity?: number | undefined`: Top-level XSPH strength; prefer `solverOptions.xsphViscosity`. ### PBFParticlesOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFParticlesOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFParticlesOptions } from "three-blocks/pbf"; interface PBFParticlesOptions ``` **Purpose:** Particle population and calibrated layout options. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFParticlesOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `calibrationMode?: PBFCalibrationMode | undefined`: Strategy used to calibrate mass and density from the reference lattice. - `count?: number | undefined`: Number of simulated particles. - `dimension?: PBFDimension | undefined`: Whether the particle layout and solver operate in two or three dimensions. - `mass?: number | 'auto' | undefined`: Per-particle mass, or `"auto"` to calibrate against rest density. - `particleRadius?: number | 'auto' | undefined`: Collision radius, or `"auto"` to derive it from spacing. - `smoothingRadius?: number | 'auto' | undefined`: Density-kernel radius, or `"auto"` to derive it from spacing. - `spacing?: number | undefined`: Center-to-center rest spacing in simulation units. ### PBFResetOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFResetOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFResetOptions } from "three-blocks/pbf"; interface PBFResetOptions ``` **Purpose:** Options for resetting particles into a deterministic CPU-generated layout. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFResetOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `center?: PBFComponents | undefined`: Layout center in simulation coordinates. - `dimension?: PBFDimension | undefined`: Dimensions of the generated layout. - `domainDimensions?: PBFComponents | undefined`: Domain dimensions used to bound generated positions. - `excessParticlePolicy?: 'repeat' | 'error' | undefined`: Behavior when the requested count exceeds unique lattice positions. - `fill?: PBFComponents | undefined`: Fractional domain fill per axis. - `jitter?: number | undefined`: Random displacement as a fraction of spacing. - `mode?: PBFInitializationMode | undefined`: Shape and sampling policy used for the reset. - `particleRadius?: number | undefined`: Collision radius reserved inside the reset domain. - `seed?: number | undefined`: Seed used for deterministic layout jitter. - `spacing?: number | undefined`: Particle spacing used by the generated layout. ### PBFSolverMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFSolverMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFSolverMaterialOptions } from "three-blocks/pbf"; interface PBFSolverMaterialOptions ``` **Purpose:** PBF-specific recommendations nested inside a material configuration. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFSolverMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `artificialPressure?: PBFArtificialPressureOptions | undefined`: Optional tensile-clumping correction. - `vorticityConfinement?: number | undefined`: Strength of optional vorticity restoration. - `xsphViscosity?: number | undefined`: Velocity-smoothing strength applied after constraint projection. ### PBFSolverOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFSolverOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFSolverOptions } from "three-blocks/pbf"; interface PBFSolverOptions ``` **Purpose:** Intentional PBF accuracy and velocity-quality controls. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFSolverOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `iterations?: number | undefined`: Number of density-constraint projection iterations per solver step. - `solverIterations?: number | undefined`: Alias for PBFSolverOptions.iterations retained for configuration objects. - `vorticityConfinement?: number | undefined`: Strength of optional small-scale rotational motion restoration. - `xsphViscosity?: number | undefined`: Velocity-smoothing strength applied after position projection. ### PBFStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFStats } from "three-blocks/pbf"; interface PBFStats ``` **Purpose:** Small read-only PBF state snapshot that does not expose live GPU resources. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `readonly calibration: Readonly | null`: Construction-time calibration snapshot, when available. - `readonly fixedDelta: number | null`: Active fixed interval, or `null` for variable stepping. - `readonly maxSubsteps: number`: Maximum fixed steps submitted for one host frame. - `readonly particleCount: number`: Number of live particles. - `readonly solver: 'pbf'`: Stable solver identifier. - `readonly spatialGrid: boolean`: Whether neighbor-grid acceleration is active. ### PBFTimeStepOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFTimeStepOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFTimeStepOptions } from "three-blocks/pbf"; interface PBFTimeStepOptions ``` **Purpose:** Fixed-step scheduling options used at construction or by `setTimeStepOptions`. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFTimeStepOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `fixedDelta?: number | null | undefined`: Fixed solver interval in seconds, or `null` for one variable step per frame. - `maxFrameDelta?: number | undefined`: Maximum accepted host-frame interval in seconds. - `maxSubsteps?: number | undefined`: Maximum fixed solver steps submitted for one host frame. - `timeScale?: number | undefined`: Simulation-speed multiplier applied without changing the host frame delta. ### PBFVectorComponents Kind: interface; canonical: https://threejs-blocks.com/docs/api/PBFVectorComponents. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { PBFVectorComponents } from "three-blocks/pbf"; interface PBFVectorComponents ``` **Purpose:** Vector-like components accepted by nested domain and initialization options. **Status:** Stable through the curated Position-Based Fluids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PBFVectorComponents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/pbf. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/pbf Direct example imports: none recorded. - `x?: number | undefined`: X component; omitted values use the operation's documented default. - `y?: number | undefined`: Y component; omitted values use the operation's documented default. - `z?: number | undefined`: Z component; ignored by two-dimensional simulations. ### PRECOMPILED_MANIFEST_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/PRECOMPILED_MANIFEST_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { PRECOMPILED_MANIFEST_VERSION } from "three-blocks/shaders"; const PRECOMPILED_MANIFEST_VERSION: 3 ``` **Purpose:** Strict, structured-clone-safe contracts for the Three Blocks shader cache. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PRECOMPILED_MANIFEST_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### PackageTextFontSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/PackageTextFontSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PackageTextFontSource } from "three-blocks/text"; interface PackageTextFontSource ``` **Purpose:** Declares PackageTextFontSource as a public interface. It is exported from three-blocks/text. Its declared surface covers checksum, file, and package. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PackageTextFontSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly checksum: string` - `readonly file: string` - `readonly package: string` ### PageLink Kind: type; canonical: https://threejs-blocks.com/docs/api/PageLink. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PageLink } from "three-blocks/app"; type PageLink = WorkerClient ``` **Purpose:** Declares PageLink as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PageLink. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ParseMSDFFontOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ParseMSDFFontOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { ParseMSDFFontOptions } from "three-blocks/msdf-text"; interface ParseMSDFFontOptions ``` **Purpose:** Options applied while normalizing font metadata. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ParseMSDFFontOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: none recorded. - `flipY?: boolean`: Whether atlas V coordinates must account for a vertically flipped texture upload. ### PointerState Kind: interface; canonical: https://threejs-blocks.com/docs/api/PointerState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PointerState } from "three-blocks/app"; interface PointerState ``` **Purpose:** Declares PointerState as a public interface. It is exported from three-blocks/app. Its declared surface covers buttons, x, and y. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PointerState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly buttons: number` - `readonly x: number` - `readonly y: number` ### PrecompiledAttribute Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledAttribute. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledAttribute } from "three-blocks/shaders"; interface PrecompiledAttribute ``` **Purpose:** Declares PrecompiledAttribute as a public interface. It is exported from three-blocks/shaders. Its declared surface covers name, node, and type. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledAttribute. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly name: string` - `readonly node: number | null`: Node pool index, or null for plain geometry attributes. - `readonly type: string` ### PrecompiledAutomaticRegistration Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledAutomaticRegistration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledAutomaticRegistration } from "three-blocks/shaders"; interface PrecompiledAutomaticRegistration ``` **Purpose:** Declares PrecompiledAutomaticRegistration as a public interface. It is exported from three-blocks/shaders. Its declared surface covers prefix. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledAutomaticRegistration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly prefix: string`: Capture-time prefix used for deterministic unregistered render/compute keys. ### PrecompiledBinding Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledBinding. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledBinding } from "three-blocks/shaders"; interface PrecompiledBinding ``` **Purpose:** Declares PrecompiledBinding as a public interface. It is exported from three-blocks/shaders. Its declared surface covers access, kind, name, store, and uniforms. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledBinding. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly access?: string`: Captured live storage access mode; hydration compares it structurally. - `readonly kind: string` - `readonly name: string` - `readonly store?: boolean`: Captured storage-texture flag for sampled-texture binding kinds. - `readonly uniforms?: readonly PrecompiledBindingUniform[]`: Exact member order for a NodeUniformsGroup's STD140 buffer. ### PrecompiledBindingGroup Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledBindingGroup. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledBindingGroup } from "three-blocks/shaders"; interface PrecompiledBindingGroup ``` **Purpose:** Declares PrecompiledBindingGroup as a public interface. It is exported from three-blocks/shaders. Its declared surface covers bindings and name. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledBindingGroup. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bindings: readonly PrecompiledBinding[]` - `readonly name: string` ### PrecompiledBindingUniform Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledBindingUniform. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledBindingUniform } from "three-blocks/shaders"; interface PrecompiledBindingUniform ``` **Purpose:** Declares PrecompiledBindingUniform as a public interface. It is exported from three-blocks/shaders. Its declared surface covers name and type. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledBindingUniform. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly name: string` - `readonly type: string` ### PrecompiledDeclaration Kind: type; canonical: https://threejs-blocks.com/docs/api/PrecompiledDeclaration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledDeclaration } from "three-blocks/shaders"; type PrecompiledDeclaration = readonly [node: number, instance: number, type: string, stage: ShaderStage, name: string | null] ``` **Purpose:** One final unique uniform declaration: `[node, instance, type, stage, name]`. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledDeclaration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### PrecompiledManifest Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledManifest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledManifest } from "three-blocks/shaders"; interface PrecompiledManifest ``` **Purpose:** Version 3 shader artifact: deterministic pools plus integer references. `three` and `runtime` are optional in the authored type so minimal status artifacts can still be inspected; runtime injection rejects their absence and safely builds live. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attributePlans: readonly (readonly PrecompiledAttribute[])[]` - `readonly automatic?: PrecompiledAutomaticRegistration` - `readonly entries: Readonly>`: Stable application key to state pool index. - `readonly fallbacks?: Readonly>`: Registered states intentionally left on the live backend path, keyed like `entries`. - `readonly layouts: readonly (readonly PrecompiledBindingGroup[])[]` - `readonly modules: readonly string[]`: Exact whole-program WGSL sources — the same identity `Pipelines` interns by. - `readonly nodes: readonly NodeAddress[]`: Deduplicated node addresses referenced by declarations and plans. - `readonly requirementPlans: readonly (readonly string[])[]`: Required optional WebGPU features per requirement plan. - `readonly requiresSetup?: boolean`: False opts into direct hydration; release parity must certify it. Absent means true. - `readonly runtime?: PrecompiledRuntimeCompatibility` - `readonly scene: string` - `readonly states: readonly PrecompiledState[]` - `readonly three?: string` - `readonly threeBlocks?: string` - `readonly updatePlans: readonly (readonly number[])[]`: Node pool indexes per update list. - `readonly version: typeof PRECOMPILED_MANIFEST_VERSION` ### PrecompiledObserver Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledObserver. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledObserver } from "three-blocks/shaders"; interface PrecompiledObserver ``` **Purpose:** Declares PrecompiledObserver as a public interface. It is exported from three-blocks/shaders. Its declared surface covers hasAnimation and hasNode. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledObserver. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly hasAnimation: boolean` - `readonly hasNode: boolean` ### PrecompiledRuntimeCompatibility Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledRuntimeCompatibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledRuntimeCompatibility } from "three-blocks/shaders"; interface PrecompiledRuntimeCompatibility ``` **Purpose:** Declares PrecompiledRuntimeCompatibility as a public interface. It is exported from three-blocks/shaders. Its declared surface covers address, hydration, id, and recipe. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledRuntimeCompatibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly address: typeof SHADER_ADDRESS_SCHEMA_VERSION` - `readonly hydration: typeof SHADER_HYDRATION_SCHEMA_VERSION` - `readonly id: string` - `readonly recipe: typeof SHADER_RECIPE_SCHEMA_VERSION` ### PrecompiledState Kind: interface; canonical: https://threejs-blocks.com/docs/api/PrecompiledState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { PrecompiledState } from "three-blocks/shaders"; interface PrecompiledState ``` **Purpose:** One hydratable NodeBuilderState record. All numeric fields index manifest pools; the same state may serve several entry keys. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for PrecompiledState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attributes: number`: Attribute-plan pool index. - `readonly compute: number | null` - `readonly declarations: readonly PrecompiledDeclaration[]` - `readonly fragment: number | null` - `readonly hardwareClipping: boolean` - `readonly layout: number`: Layout pool index. - `readonly observer: PrecompiledObserver | null` - `readonly requirements?: number`: Requirement-plan pool index; absent when the state needs no optional features. - `readonly updates: readonly [number, number, number]`: Update-plan pool indexes: [updateNodes, updateBeforeNodes, updateAfterNodes]. - `readonly vertex: number | null`: Module pool indexes per stage; compute states leave vertex/fragment null. ### ProjectTextFontSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/ProjectTextFontSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ProjectTextFontSource } from "three-blocks/text"; interface ProjectTextFontSource ``` **Purpose:** Declares ProjectTextFontSource as a public interface. It is exported from three-blocks/text. Its declared surface covers path. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ProjectTextFontSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly path: string` ### RafOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/RafOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RafOptions } from "three-blocks/runtime"; interface RafOptions ``` **Purpose:** Declares RafOptions as a public interface. It is exported from three-blocks/runtime. Its declared surface covers fps, maxDelta, and renderPriority. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RafOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly fps?: number`: `onThrottle` frequency. `Infinity` runs it every frame; values <= 0 disable it. - `readonly maxDelta?: number`: Optional component-specific delta cap in seconds. - `readonly renderPriority?: number`: Lower priorities run first. Renderers normally use `Infinity`. ### RayMarchSDFMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/RayMarchSDFMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { RayMarchSDFMaterialOptions } from "three-blocks/sdf-raymarching"; interface RayMarchSDFMaterialOptions ``` **Purpose:** Construction configuration for RayMarchSDFNodeMaterial. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RayMarchSDFMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `absorptionColor?: THREE.ColorRepresentation | undefined`: Per-unit-depth body transmission color. - `absorptionDensity?: number | undefined`: Optical density applied to measured body paths. - `backgroundAlpha?: number | undefined`: Background opacity; use zero when compositing over another render. - `backgroundBottom?: THREE.ColorRepresentation | undefined`: Bottom color of the optional material-generated background. - `backgroundTop?: THREE.ColorRepresentation | undefined`: Top color of the optional material-generated background. - `cloudStrength?: number | undefined`: Low-frequency field-local interior density variation. - `color?: THREE.ColorRepresentation | undefined`: Base surface color. - `dispersion?: number | undefined`: Exit-only red/green/blue refraction spread. - `ditherStrength?: number | undefined`: Integer-pixel final-gradient dither strength. - `envIntensity?: number | undefined`: Analytic studio-environment blend; zero preserves legacy reflection and background shading. - `exposure?: number | undefined`: Output exposure in stops. - `filmic?: number | undefined`: AgX output-transform blend. - `finishIntensity?: number | undefined`: Dual-lobe polished-surface reflection blend. - `highlightColor?: THREE.ColorRepresentation | undefined`: Rim and specular highlight color. - `ior?: number | undefined`: Interior index of refraction; one preserves the straight transmission path. - `marchJitter?: number | undefined`: Integer-pixel primary-ray offset strength. - `quality?: number | undefined`: Performance tier from zero through four. Lower tiers reduce field-noise octaves, disable dispersion, then reduce cone-light transport taps. - `roughness?: number | undefined`: Perceptual surface roughness. - `scatterColor?: THREE.ColorRepresentation | undefined`: Tint applied to light scattered through the body. - `scatterSoftness?: number | undefined`: Terminator, phase-skirt, and cone-light softening blend. - `stepScale?: number | undefined`: Conservative sphere-tracing multiplier balancing speed against missed surfaces. - `surfaceDetail?: number | undefined`: Surface-only micro-normal and roughness variation. - `translucency?: number | undefined`: Subsurface scattering blend; zero preserves the opaque material path. - `veinColor?: THREE.ColorRepresentation | undefined`: Per-unit-depth transmission color inside veins. - `veinStrength?: number | undefined`: Ridged field-local vein extinction strength. ### RayMarchSDFNodeMaterial Kind: variable; canonical: https://threejs-blocks.com/docs/api/RayMarchSDFNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { RayMarchSDFNodeMaterial } from "three-blocks/sdf-raymarching"; const RayMarchSDFNodeMaterial: RayMarchSDFNodeMaterialConstructor ``` **Purpose:** Three.js material that ray-marches a caller-owned SDF texture. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_points_bvh_volume. - `new (sdfTexture: SDFTextureOutput, options?: RayMarchSDFMaterialOptions): RayMarchSDFNodeMaterial`: Construct a material that borrows the supplied three-dimensional texture. - `dispose(): void`: Dispatch the standard Three.js material disposal event without disposing the texture. - `readonly isRayMarchSDFNodeMaterial: boolean`: Runtime type guard identifying this specialized material. ### RaymarchingBox Kind: variable; canonical: https://threejs-blocks.com/docs/api/RaymarchingBox. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { RaymarchingBox } from "three-blocks/sdf-raymarching"; const RaymarchingBox: (steps: TSLFloatInput, callback: RaymarchingBoxCallback, sampleOffset?: TSLFloatInput, onBeforeLoop?: RaymarchingBoxSetupCallback | null, maxDistance?: TSLFloatInput | null) => void ``` **Purpose:** TSL function for performing raymarching in a box-area using the specified number of steps and a callback function. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RaymarchingBox. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. ### RegisterDevtoolsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/RegisterDevtoolsOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RegisterDevtoolsOptions } from "three-blocks/devtools"; interface RegisterDevtoolsOptions ``` **Purpose:** Declares RegisterDevtoolsOptions as a public interface. It is exported from three-blocks/devtools. Its declared surface covers announce, container, overlay, renderer, and shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RegisterDevtoolsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly announce?: boolean`: Print the one-time measured shader state announcement. Defaults to true. - `readonly container?: HTMLElement`: Panel mount target. Defaults to document.body. - `readonly overlay?: boolean`: Auto-mount the static development overlay when no Vite overlay is present. Defaults to true. - `readonly renderer: WebGPURenderer`: A page-owned Three.js WebGPURenderer. WebGLRenderer is not supported. - `readonly shaders?: ThreeBlocksShaderBuildConfig`: Build-injected receipt policy. Bundler integrations populate this automatically. ### RemoteWorkerError Kind: class; canonical: https://threejs-blocks.com/docs/api/RemoteWorkerError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { RemoteWorkerError } from "three-blocks/worker"; class RemoteWorkerError extends Error ``` **Purpose:** Declares RemoteWorkerError as a public class. It is exported from three-blocks/worker. Its declared surface covers remote, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(remote: SerializedWorkerError)` - `readonly remote: SerializedWorkerError` ### RenderSDFLayerNodeMaterial Kind: class; canonical: https://threejs-blocks.com/docs/api/RenderSDFLayerNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { RenderSDFLayerNodeMaterial } from "three-blocks/sdf-raymarching"; class RenderSDFLayerNodeMaterial extends NodeMaterial ``` **Purpose:** Material for rendering individual slices/layers of 3D SDF textures. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `constructor(sdfTexture: Storage3DTexture)`: Create an SDF slice-debug material for a 3D storage texture. ### RequestDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/RequestDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RequestDefinition } from "three-blocks/worker"; interface RequestDefinition ``` **Purpose:** Declares RequestDefinition as a public interface. It is exported from three-blocks/worker. Its declared surface covers parameters and result. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RequestDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly parameters: TParameters` - `readonly result: TResult` ### RequestParameters Kind: type; canonical: https://threejs-blocks.com/docs/api/RequestParameters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RequestParameters } from "three-blocks/worker"; type RequestParameters = TDefinition extends RequestDefinition ? TParameters: never ``` **Purpose:** Declares RequestParameters as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RequestParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### RequestResult Kind: type; canonical: https://threejs-blocks.com/docs/api/RequestResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RequestResult } from "three-blocks/worker"; type RequestResult = TDefinition extends RequestDefinition ? TResult: never ``` **Purpose:** Declares RequestResult as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RequestResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### RuntimeComponent Kind: type; canonical: https://threejs-blocks.com/docs/api/RuntimeComponent. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RuntimeComponent } from "three-blocks/runtime"; type RuntimeComponent = FrameLifecycle & EventMethodMap ``` **Purpose:** Declares RuntimeComponent as a public type. It is exported from three-blocks/runtime. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RuntimeComponent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### RuntimeDiagnostics Kind: interface; canonical: https://threejs-blocks.com/docs/api/RuntimeDiagnostics. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RuntimeDiagnostics } from "three-blocks/app"; interface RuntimeDiagnostics ``` **Purpose:** Declares RuntimeDiagnostics as a public interface. It is exported from three-blocks/app. Its declared surface covers scroll, shaderMode, shaders, viewport, and visible, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RuntimeDiagnostics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly scroll: ScrollState` - `readonly shaderMode: 'precompiled' | 'live'` - `readonly shaders?: ThreeBlocksShaderRuntimeSnapshot`: Actual registered shader builds observed by the worker runtime. - `readonly viewport: ViewportState` - `readonly visible: boolean` - `readonly workerId: string` ### RuntimeStage Kind: type; canonical: https://threejs-blocks.com/docs/api/RuntimeStage. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RuntimeStage } from "three-blocks/app"; type RuntimeStage = 'starting' | 'worker ready' | 'assets ready' | 'compiled' | 'first frame' | 'updating' | 'error' ``` **Purpose:** Declares RuntimeStage as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RuntimeStage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### RuntimeStatus Kind: interface; canonical: https://threejs-blocks.com/docs/api/RuntimeStatus. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { RuntimeStatus } from "three-blocks/app"; interface RuntimeStatus ``` **Purpose:** Declares RuntimeStatus as a public interface. It is exported from three-blocks/app. Its declared surface covers detail and stage. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for RuntimeStatus. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly detail?: string` - `readonly stage: RuntimeStage` ### SDFBoundaryApplyOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SDFBoundaryApplyOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFBoundaryApplyOptions } from "three-blocks/sdf-raymarching"; interface SDFBoundaryApplyOptions ``` **Purpose:** Per-dispatch response configuration shared by BVH and SDF constraints. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFBoundaryApplyOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `hardProjection?: boolean | undefined`: Resolve the full measured penetration in one dispatch. - `particleRadius?: number | undefined`: Particle-center offset added to the effective boundary distance. - `positionOnly?: boolean | undefined`: Correct positions without applying a velocity response. - `velocityOnly?: boolean | undefined`: Apply a velocity response without correcting positions. ### SDFGeneratorOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SDFGeneratorOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFGeneratorOptions } from "three-blocks/sdf-raymarching"; interface SDFGeneratorOptions ``` **Purpose:** Construction configuration for ComputeSDFGenerator. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFGeneratorOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `bounds?: THREE.Box3 | null | undefined`: Optional caller-owned fixed volume bounds, read during each generation. - `margin?: number | undefined`: World-space padding added around automatically calculated mesh bounds. - `resolution?: number | undefined`: Cubic voxel dimension; memory and generation work grow with its cube. - `threshold?: number | undefined`: Signed-distance bias written into every generated voxel. ### SDFParticleVectorStorage Kind: type; canonical: https://threejs-blocks.com/docs/api/SDFParticleVectorStorage. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFParticleVectorStorage } from "three-blocks/sdf-raymarching"; type SDFParticleVectorStorage = THREE.StorageBufferAttribute | THREE.StorageBufferNode<'vec3'> ``` **Purpose:** Caller-owned vector storage modified in place by a particle constraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFParticleVectorStorage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### SDFSliceVolumeNodeMaterial Kind: class; canonical: https://threejs-blocks.com/docs/api/SDFSliceVolumeNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SDFSliceVolumeNodeMaterial } from "three-blocks/sdf-raymarching"; class SDFSliceVolumeNodeMaterial extends NodeMaterial ``` **Purpose:** Back-to-front depth-slice renderer for inspecting a 3D SDF in scene space. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_points_bvh_volume. - `constructor(sdfTexture: import('three/webgpu').Storage3DTexture, options?: SDFSliceVolumeNodeMaterialOptions)`: Create an instanced SDF slice-volume material. - `isSDFSliceVolumeNodeMaterial: boolean`: Runtime type guard that is always `true` for this material. - `sliceVolumeUniforms: SDFSliceVolumeUniforms`: Mutable slice presentation uniforms. ### SDFTextureOutput Kind: type; canonical: https://threejs-blocks.com/docs/api/SDFTextureOutput. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFTextureOutput } from "three-blocks/sdf-raymarching"; type SDFTextureOutput = THREE.Storage3DTexture ``` **Purpose:** GPU-owned three-dimensional texture produced by an SDF generator. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFTextureOutput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### SDFVolumeConstraint Kind: variable; canonical: https://threejs-blocks.com/docs/api/SDFVolumeConstraint. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SDFVolumeConstraint } from "three-blocks/sdf-raymarching"; const SDFVolumeConstraint: SDFVolumeConstraintConstructor ``` **Purpose:** Particle-volume constraint sampling a generated SDF. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `apply(renderer: THREE.Renderer, positions: SDFParticleVectorStorage, velocities: SDFParticleVectorStorage, particleCount: number, options?: SDFBoundaryApplyOptions): Promise`: Submit one in-place SDF boundary response after preceding simulation writes. - `new (source: SDFVolumeSource | null, options?: SDFVolumeConstraintOptions): SDFVolumeConstraint`: Construct a lazy SDF constraint around a borrowed source. - `damping: number`: Normal-velocity damping used by subsequent dispatches. - `dispose(): void`: Release cached passes without disposing the source, texture, or particle buffers. - `readonly sdfGenerator: SDFVolumeSource | null`: Current borrowed source, or `null` to disable dispatches. - `stiffness: number`: Penetration correction strength used by subsequent dispatches. - `threshold: number`: Signed-distance surface offset used by subsequent dispatches. - `updateSDF(source: SDFVolumeSource | null): void`: Replace the borrowed source and invalidate all cached compute passes. ### SDFVolumeConstraintOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SDFVolumeConstraintOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFVolumeConstraintOptions } from "three-blocks/sdf-raymarching"; interface SDFVolumeConstraintOptions ``` **Purpose:** Persistent response configuration for SDFVolumeConstraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFVolumeConstraintOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `damping?: number | undefined`: Normal-velocity damping applied during collision response. - `stiffness?: number | undefined`: Penetration correction strength. - `threshold?: number | undefined`: Signed-distance surface offset. ### SDFVolumeSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/SDFVolumeSource. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SDFVolumeSource } from "three-blocks/sdf-raymarching"; interface SDFVolumeSource ``` **Purpose:** Borrowed SDF resource surface consumed by SDFVolumeConstraint. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SDFVolumeSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `readonly boundsMatrix: THREE.Matrix4`: Mutable normalized-volume-to-world transform read before each dispatch. - `readonly inverseBoundsMatrix: THREE.Matrix4`: Mutable world-to-normalized-volume transform read before each dispatch. - `readonly resolution: number`: Cubic texture resolution used to derive gradient sample spacing. - `readonly sdfTexture?: SDFTextureOutput | null | undefined`: Current borrowed SDF texture; a missing value makes `apply()` a no-op. ### SHADER_ADDRESS_SCHEMA_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/SHADER_ADDRESS_SCHEMA_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SHADER_ADDRESS_SCHEMA_VERSION } from "three-blocks/shaders"; const SHADER_ADDRESS_SCHEMA_VERSION: 2 ``` **Purpose:** Declares SHADER_ADDRESS_SCHEMA_VERSION as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SHADER_ADDRESS_SCHEMA_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SHADER_CAPTURE_CACHE_HOOK Kind: variable; canonical: https://threejs-blocks.com/docs/api/SHADER_CAPTURE_CACHE_HOOK. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SHADER_CAPTURE_CACHE_HOOK } from "three-blocks/shaders"; const SHADER_CAPTURE_CACHE_HOOK: unique symbol ``` **Purpose:** Symbol-keyed, devtools-only observer. No capture implementation ships in this module. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SHADER_CAPTURE_CACHE_HOOK. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SHADER_CAPTURE_CACHE_VALUE Kind: variable; canonical: https://threejs-blocks.com/docs/api/SHADER_CAPTURE_CACHE_VALUE. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SHADER_CAPTURE_CACHE_VALUE } from "three-blocks/shaders"; const SHADER_CAPTURE_CACHE_VALUE: unique symbol ``` **Purpose:** Last application cache to register or activate a scene, shared across package copies. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SHADER_CAPTURE_CACHE_VALUE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SHADER_HYDRATION_SCHEMA_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/SHADER_HYDRATION_SCHEMA_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SHADER_HYDRATION_SCHEMA_VERSION } from "three-blocks/shaders"; const SHADER_HYDRATION_SCHEMA_VERSION: 2 ``` **Purpose:** Declares SHADER_HYDRATION_SCHEMA_VERSION as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SHADER_HYDRATION_SCHEMA_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SHADER_RECIPE_SCHEMA_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/SHADER_RECIPE_SCHEMA_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SHADER_RECIPE_SCHEMA_VERSION } from "three-blocks/shaders"; const SHADER_RECIPE_SCHEMA_VERSION: 1 ``` **Purpose:** Declares SHADER_RECIPE_SCHEMA_VERSION as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SHADER_RECIPE_SCHEMA_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SPH Kind: variable; canonical: https://threejs-blocks.com/docs/api/SPH. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SPH } from "three-blocks"; import { SPH } from "three-blocks/sph"; const SPH: SPHConstructor ``` **Purpose:** Stable declaration-facing façade for the Smoothed Particle Hydrodynamics engine. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `new (options?: SPHOptions): SPH`: Construct an SPH engine and allocate its owned GPU storage. Throws: Error — If calibration, initial layout, or GPU storage construction fails; TypeError — If an external initial-position source is incompatible. - `dispose(): void`: Release engine-owned grids, storage resources, compute passes, and GUI bindings. Caller-owned renderers, domain objects, initial-position sources, and render assets are untouched. Repeated host teardown may call this method safely; do not step after disposal. - `getLastMetrics(): Readonly | null`: Return the latest immutable metric snapshot, or `null` before a requested readback completes. - `getRequiredRendererLimits(): Readonly`: Return immutable binding limits needed before renderer/device creation. - `getStats(): Readonly`: Return lightweight synchronous state without exposing live GPU resources. - `readonly particleCount: number`: Number of live particles advanced by each step. - `requestMetricsReadback(): this`: Request one asynchronous diagnostic readback after the next completed step. Readback can stall the GPU; it is never performed unless explicitly requested. - `reset(renderer: Renderer, options?: SPHResetOptions): Promise`: Replace live particle positions with a deterministic generated layout. Await any active step first and call before rendering the next frame. - `setDomainDimensions(dimensions: Vector3): this`: Resize the axis-aligned domain and synchronize neighbor acceleration. Call between steps. - `setDomainFromObject(object: Object3D, options?: SPHDomainBindingOptions): this`: Bind the simulation domain to a caller-owned Three.js object. The object is observed but never disposed by the simulation. - `setMass(value: number): this`: Set particle mass and refresh automatic density calibration when enabled. Call between frames before the next solver step. - `setRestDensity(value: number | null | undefined): this`: Set target density, or pass `null` to restore calibrated automatic density. Call between frames before the next solver step. - `setSmoothingRadius(radius: number): this`: Change the density-kernel radius and rebuild dependent coefficients. Call between frames; active neighbor acceleration is synchronized automatically. - `setSpatialGridEnabled(enabled: boolean): this`: Enable or disable engine-owned neighbor-grid acceleration between frames. - `setTimeStepOptions(options?: SPHTimeStepOptions): this`: Update fixed-step scheduling between frames. Changes apply to the next SPH.step call. - `step(renderer: Renderer, deltaTime?: number | undefined): Promise`: Advance GPU state for one host frame. Update controls and bound objects first, await this method, then render. The first call may initialize the renderer and copy initial positions. ### SPHCalibrationMode Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHCalibrationMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHCalibrationMode } from "three-blocks/sph"; type SPHCalibrationMode = 'manual' | 'particle-volume' | 'self-kernel' | 'discrete-lattice' ``` **Purpose:** Supported calibration strategies for particle spacing, mass, and kernel radius. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHCalibrationMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHCalibrationSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHCalibrationSnapshot. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHCalibrationSnapshot } from "three-blocks/sph"; interface SPHCalibrationSnapshot ``` **Purpose:** Read-only calibration result selected during construction. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHCalibrationSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `readonly dimension: 2 | 3`: Resolved simulation dimensionality. - `readonly expectedNeighborCount: number`: Expected neighbors in the reference lattice. - `readonly mode: SPHCalibrationMode`: Calibration strategy that produced the snapshot. - `readonly neighborQuality: 'low' | 'useful'`: Coarse warning tier for neighbor support. - `readonly particleMass: number`: Resolved particle mass. - `readonly particleRadius: number`: Resolved collision radius. - `readonly referenceDensity: number`: Density reproduced by the reference lattice. - `readonly referenceDensityError: number`: Relative reference-lattice density error. - `readonly restDensity: number`: Resolved target rest density. - `readonly smoothingRadius: number`: Resolved kernel radius. - `readonly smoothingRadiusRatio: number`: Kernel radius divided by particle spacing. - `readonly spacing: number`: Resolved rest spacing. ### SPHComponents Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHComponents. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHComponents } from "three-blocks/sph"; type SPHComponents = number[] | SPHVectorComponents ``` **Purpose:** Compact vector input accepted by SPH configuration sections. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHComponents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHDiagnosticsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHDiagnosticsOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHDiagnosticsOptions } from "three-blocks/sph"; interface SPHDiagnosticsOptions ``` **Purpose:** Opt-in diagnostic configuration retained by the metrics subsystem. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHDiagnosticsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `accelerationComponents?: boolean | undefined`: Whether pressure and viscosity acceleration summaries are retained for readback. - `enabled?: boolean | undefined`: Whether the host intends to collect diagnostic snapshots. ### SPHDimension Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHDimension. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHDimension } from "three-blocks/sph"; type SPHDimension = 2 | 3 | '2d' | '3d' ``` **Purpose:** Dimensionality accepted by nested particle configuration. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHDimension. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHDomainBindingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHDomainBindingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHDomainBindingOptions } from "three-blocks/sph"; interface SPHDomainBindingOptions ``` **Purpose:** Options for binding the simulation domain to a Three.js object's bounds. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHDomainBindingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `autoUpdate?: boolean | undefined`: Whether object transforms are refreshed before every solver step. - `padding?: number | Vector3 | undefined`: Padding added around the object's local bounds. - `simulationScale?: number | Vector3 | null | undefined`: Optional simulation-to-object scale override. ### SPHDomainOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHDomainOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHDomainOptions } from "three-blocks/sph"; interface SPHDomainOptions ``` **Purpose:** Axis-aligned domain and boundary-response configuration. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHDomainOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `dimensions?: SPHComponents | Vector3 | undefined`: Domain dimensions expressed as components or a Three.js `Vector3`. - `friction?: number | undefined`: Tangential damping applied at boundaries. - `particleRadiusOffset?: boolean | undefined`: Whether particle radius is included when projecting against box boundaries. - `restitution?: number | undefined`: Normal velocity retained after a boundary collision, from `0` to `1`. ### SPHEquationOfState Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHEquationOfState. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHEquationOfState } from "three-blocks/sph"; type SPHEquationOfState = 'linear' | 'tait' ``` **Purpose:** Pressure model used to convert density error into acceleration. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHEquationOfState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHInitialPositions Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHInitialPositions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHInitialPositions } from "three-blocks/sph"; type SPHInitialPositions = StorageBufferAttribute | StorageInstancedBufferAttribute ``` **Purpose:** GPU storage accepted as an initial SPH particle-position source. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHInitialPositions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHInitializationMode Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHInitializationMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHInitializationMode } from "three-blocks/sph"; type SPHInitializationMode = 'block-lattice' | 'block-jittered-lattice' | 'sphere-lattice' | 'random-domain' ``` **Purpose:** Deterministic CPU layout used when no initial GPU position source is supplied. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHInitializationMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHInitializationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHInitializationOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHInitializationOptions } from "three-blocks/sph"; interface SPHInitializationOptions ``` **Purpose:** Deterministic initial particle-layout configuration. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHInitializationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `fill?: SPHComponents | undefined`: Fractional domain fill per axis. - `jitter?: number | undefined`: Random displacement as a fraction of particle spacing. - `mode?: SPHInitializationMode | undefined`: Shape and sampling policy used to generate positions. - `seed?: number | undefined`: Seed used by deterministic layout jitter. ### SPHMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHMaterialOptions } from "three-blocks/sph"; interface SPHMaterialOptions ``` **Purpose:** Physical material configuration resolved when constructing an SPH simulation. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `preset?: SPHMaterialPreset | undefined`: Named baseline whose remaining fields may be overridden below. - `restDensity?: number | undefined`: Target rest density in simulation mass units. - `sph?: SPHSolverMaterialOptions | undefined`: SPH-specific material recommendations. - `surfaceTension?: number | undefined`: Surface-tension recommendation retained in the material snapshot. - `viscosity?: number | undefined`: Dynamic-viscosity recommendation used by the preset system. ### SPHMaterialPreset Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHMaterialPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHMaterialPreset } from "three-blocks/sph"; type SPHMaterialPreset = 'water' | 'viscousLiquid' | 'gelLike' | 'custom' ``` **Purpose:** Outcome-oriented material presets understood by the fluid configuration normalizer. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHMaterialPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHMetricSummary Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHMetricSummary. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHMetricSummary } from "three-blocks/sph"; interface SPHMetricSummary ``` **Purpose:** Aggregate minimum, mean, and maximum for a sampled metric. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHMetricSummary. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `readonly maximum: number`: Largest sampled value. - `readonly mean: number`: Arithmetic mean across live particles. - `readonly minimum: number`: Smallest sampled value. ### SPHMetrics Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHMetrics. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHMetrics } from "three-blocks/sph"; interface SPHMetrics ``` **Purpose:** Read-only, opt-in SPH diagnostic snapshot produced after a requested step. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHMetrics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `readonly boundaries: Readonly<{/** Projected particle count when supplied by an active boundary provider. */ projectedParticles: number | null; /** Maximum measured boundary penetration when available. */ maximumPenetration: number | null; /** Number of particle pairs closer than the overlap threshold. */ overlapPairs: number;}>`: Boundary and overlap diagnostics available without exposing live buffers. - `readonly density: Readonly<{/** Mean ratio of measured density to rest density. */ meanRatio: number; /** Root-mean-square density error. */ rmsError: number; /** Largest measured density ratio. */ maximumRatio: number; /** Largest positive density error. */ maximumPositiveError: number;}>`: Density error relative to configured rest density. - `readonly neighbors: Readonly`: Neighbor count distribution over live particles. - `readonly solver: Readonly<{/** Stable solver identifier. */ type: 'sph'; /** Optional pressure-acceleration magnitude summary. */ pressureAcceleration?: Readonly | undefined; /** Optional viscosity-acceleration magnitude summary. */ viscosityAcceleration?: Readonly | undefined;}>`: Solver-specific diagnostic summaries. - `readonly velocity: Readonly<{/** Largest sampled speed. */ maximum: number; /** Mean sampled speed. */ mean: number;}>`: Particle-speed distribution for the sampled frame. ### SPHNegativePressurePolicy Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHNegativePressurePolicy. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHNegativePressurePolicy } from "three-blocks/sph"; type SPHNegativePressurePolicy = 'allow' | 'clamp' ``` **Purpose:** Policy for pressure values below the configured rest density. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHNegativePressurePolicy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHNeighborOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHNeighborOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHNeighborOptions } from "three-blocks/sph"; interface SPHNeighborOptions ``` **Purpose:** Neighbor-acceleration policy selected at construction. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHNeighborOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `buildAlgorithm?: 'auto' | 'atomic' | 'sort' | undefined`: Grid build strategy; `"auto"` selects a renderer-appropriate implementation. - `enabled?: boolean | undefined`: Whether to build and query a spatial neighbor grid. - `lookupAlgorithm?: 'global' | 'workgroup' | undefined`: Neighbor lookup strategy used by solver passes. ### SPHOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHOptions } from "three-blocks/sph"; interface SPHOptions ``` **Purpose:** Stable SPH construction options. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `boundaryDensitySupport?: boolean | undefined`: Whether supported external boundaries contribute to density estimates. - `calibrationMode?: SPHCalibrationMode | undefined`: Top-level calibration strategy; prefer `particles.calibrationMode`. - `count?: number | undefined`: Top-level flat particle count; prefer `particles.count`. - `debug?: boolean | undefined`: Whether optional diagnostics are collected. - `densityDiffusion?: number | undefined`: Top-level density diffusion; prefer `solverOptions.densityDiffusion`. - `diagnostics?: SPHDiagnosticsOptions | null | undefined`: Opt-in diagnostic behavior. - `domain?: SPHDomainOptions | null | undefined`: Simulation domain and boundary response. - `domainDimensions?: Vector3 | SPHComponents | undefined`: Top-level domain dimensions; prefer `domain.dimensions`. - `equationOfState?: SPHEquationOfState | undefined`: Top-level pressure equation; prefer `solverOptions.equationOfState`. - `fixedTimeStep?: number | null | undefined`: Top-level fixed interval; prefer `timeStep.fixedDelta`. - `friction?: number | undefined`: Top-level boundary friction; prefer `domain.friction`. - `gamma?: number | undefined`: Top-level Tait exponent; prefer `solverOptions.gamma`. - `gravity?: Vector3 | undefined`: Constant world-space acceleration applied to every particle. - `h?: number | undefined`: Top-level smoothing radius; prefer `particles.smoothingRadius`. - `initialPositions?: SPHInitialPositions | null | undefined`: Caller-owned GPU positions copied into engine storage on first use. - `initialization?: SPHInitializationOptions | null | undefined`: Deterministic initial layout when `initialPositions` is omitted. - `is3D?: boolean | undefined`: Top-level dimensionality switch; prefer `particles.dimension`. - `kinematicViscosity?: number | undefined`: Top-level viscosity; prefer `solverOptions.kinematicViscosity`. - `mass?: number | undefined`: Top-level particle mass; prefer `particles.mass`. - `material?: SPHMaterialOptions | null | undefined`: Physical material preset and overrides. - `maxFrameDelta?: number | undefined`: Top-level host-delta cap; prefer `timeStep.maxFrameDelta`. - `maxSpeed?: number | undefined`: Maximum particle speed used to clamp divergent updates. - `maxSubsteps?: number | undefined`: Top-level substep cap; prefer `timeStep.maxSubsteps`. - `negativePressurePolicy?: SPHNegativePressurePolicy | undefined`: Treatment of pressure below rest density. - `neighbors?: SPHNeighborOptions | null | undefined`: Neighbor-acceleration policy. - `particleRadius?: number | null | undefined`: Top-level collision radius; prefer `particles.particleRadius`. - `particles?: SPHParticlesOptions | null | undefined`: Calibrated particle population and layout. - `pressureFloor?: number | undefined`: Lower pressure bound used when negative pressure is clamped. - `pressureStiffness?: number | undefined`: Linear-equation pressure stiffness retained for existing constructors. - `restDensity?: number | null | undefined`: Top-level rest density; `null` enables calibration. - `restitution?: number | undefined`: Top-level boundary restitution; prefer `domain.restitution`. - `scaleKernelWithDomain?: boolean | undefined`: Whether kernel radius follows object-domain scale changes. - `scatterZeroInitialPositions?: boolean | undefined`: Whether zero-valued external positions are scattered during initialization. - `solverOptions?: SPHSolverOptions | null | undefined`: Pressure, viscosity, and stabilization controls. - `spacing?: number | null | undefined`: Top-level rest spacing; prefer `particles.spacing`. - `speedOfSound?: number | undefined`: Top-level sound-speed control; prefer `solverOptions.speedOfSound`. - `timeScale?: number | undefined`: Top-level speed multiplier; prefer `timeStep.timeScale`. - `timeStep?: SPHTimeStepOptions | null | undefined`: Fixed-step scheduling and safety policy. - `timeStepPolicy?: SPHTimeStepPolicy | undefined`: Top-level safety policy; prefer `timeStep.policy`. - `useDirection?: boolean | undefined`: Whether internal render integration computes smoothed directions. - `useMatrices?: boolean | undefined`: Whether internal render integration computes instance transforms. - `useSpatialGrid?: boolean | undefined`: Top-level neighbor-grid toggle; prefer `neighbors.enabled`. - `viscosityMu?: number | undefined`: Dynamic-viscosity scale retained for existing constructors. ### SPHParticlesOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHParticlesOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHParticlesOptions } from "three-blocks/sph"; interface SPHParticlesOptions ``` **Purpose:** Particle population and calibrated layout options. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHParticlesOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `calibrationMode?: SPHCalibrationMode | undefined`: Strategy used to calibrate mass and density from the reference lattice. - `count?: number | undefined`: Number of simulated particles. - `dimension?: SPHDimension | undefined`: Whether the particle layout and solver operate in two or three dimensions. - `mass?: number | 'auto' | undefined`: Per-particle mass, or `"auto"` to calibrate against rest density. - `particleRadius?: number | 'auto' | undefined`: Collision radius, or `"auto"` to derive it from spacing. - `smoothingRadius?: number | 'auto' | undefined`: Density-kernel radius, or `"auto"` to derive it from spacing. - `spacing?: number | undefined`: Center-to-center rest spacing in simulation units. ### SPHRendererLimits Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHRendererLimits. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHRendererLimits } from "three-blocks/sph"; interface SPHRendererLimits ``` **Purpose:** Renderer limits required by the currently enabled SPH diagnostic outputs. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHRendererLimits. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `readonly maxStorageBuffersPerShaderStage: number`: Minimum storage-buffer binding count required for one shader stage. ### SPHResetOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHResetOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHResetOptions } from "three-blocks/sph"; interface SPHResetOptions ``` **Purpose:** Options for resetting particles into a deterministic CPU-generated layout. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHResetOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `center?: SPHComponents | undefined`: Layout center in simulation coordinates. - `dimension?: SPHDimension | undefined`: Dimensions of the generated layout. - `domainDimensions?: SPHComponents | undefined`: Domain dimensions used to bound generated positions. - `excessParticlePolicy?: 'repeat' | 'error' | undefined`: Behavior when the requested count exceeds unique lattice positions. - `fill?: SPHComponents | undefined`: Fractional domain fill per axis. - `jitter?: number | undefined`: Random displacement as a fraction of spacing. - `mode?: SPHInitializationMode | undefined`: Shape and sampling policy used for the reset. - `particleRadius?: number | undefined`: Collision radius reserved inside the reset domain. - `seed?: number | undefined`: Seed used for deterministic layout jitter. - `spacing?: number | undefined`: Particle spacing used by the generated layout. ### SPHSolverMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHSolverMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHSolverMaterialOptions } from "three-blocks/sph"; interface SPHSolverMaterialOptions ``` **Purpose:** SPH-specific recommendations nested inside a material configuration. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHSolverMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `densityDiffusion?: number | undefined`: Optional density-diffusion strength. - `equationOfState?: SPHEquationOfState | undefined`: Pressure equation used for density error. - `gamma?: number | undefined`: Tait equation exponent. - `kinematicViscosity?: number | undefined`: Kinematic viscosity converted into solver force coefficients. - `speedOfSound?: number | undefined`: Nominal speed of sound used by the Tait pressure model. - `surfaceTension?: number | undefined`: Optional surface-tension recommendation. ### SPHSolverOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHSolverOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHSolverOptions } from "three-blocks/sph"; interface SPHSolverOptions ``` **Purpose:** Intentional SPH pressure, viscosity, and stabilization controls. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHSolverOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `densityDiffusion?: number | undefined`: Optional density-diffusion strength. - `equationOfState?: SPHEquationOfState | undefined`: Pressure equation used for density error. - `gamma?: number | undefined`: Tait equation exponent. - `kinematicViscosity?: number | undefined`: Kinematic-viscosity coefficient. - `speedOfSound?: number | undefined`: Nominal speed of sound used by the Tait pressure model. ### SPHStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHStats } from "three-blocks/sph"; interface SPHStats ``` **Purpose:** Small read-only SPH state snapshot that does not expose live GPU resources. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `readonly calibration: Readonly | null`: Construction-time calibration snapshot, when available. - `readonly fixedDelta: number | null`: Active fixed interval, or `null` for variable stepping. - `readonly maxSubsteps: number`: Maximum fixed steps submitted for one host frame. - `readonly particleCount: number`: Number of live particles. - `readonly solver: 'sph'`: Stable solver identifier. - `readonly spatialGrid: boolean`: Whether neighbor-grid acceleration is active. ### SPHTimeStepOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHTimeStepOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHTimeStepOptions } from "three-blocks/sph"; interface SPHTimeStepOptions ``` **Purpose:** Fixed-step scheduling options used at construction or by `setTimeStepOptions`. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHTimeStepOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `fixedDelta?: number | null | undefined`: Fixed solver interval in seconds, or `null` for one variable step per frame. - `maxFrameDelta?: number | undefined`: Maximum accepted host-frame interval in seconds. - `maxSubsteps?: number | undefined`: Maximum fixed solver steps submitted for one host frame. - `policy?: SPHTimeStepPolicy | undefined`: Stability validation applied before GPU work is submitted. - `timeScale?: number | undefined`: Simulation-speed multiplier applied without changing the host frame delta. ### SPHTimeStepPolicy Kind: type; canonical: https://threejs-blocks.com/docs/api/SPHTimeStepPolicy. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHTimeStepPolicy } from "three-blocks/sph"; type SPHTimeStepPolicy = 'fixed' | 'validated-fixed' ``` **Purpose:** Fixed-step safety policy applied by the solver. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHTimeStepPolicy. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. ### SPHVectorComponents Kind: interface; canonical: https://threejs-blocks.com/docs/api/SPHVectorComponents. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SPHVectorComponents } from "three-blocks/sph"; interface SPHVectorComponents ``` **Purpose:** Vector-like components accepted by nested domain and initialization options. **Status:** Stable through the curated Smoothed Particle Hydrodynamics block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SPHVectorComponents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sph. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sph Direct example imports: none recorded. - `x?: number | undefined`: X component; omitted values use the operation's documented default. - `y?: number | undefined`: Y component; omitted values use the operation's documented default. - `z?: number | undefined`: Z component; ignored by two-dimensional simulations. ### STATS_PANEL_SIZE Kind: variable; canonical: https://threejs-blocks.com/docs/api/STATS_PANEL_SIZE. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { STATS_PANEL_SIZE } from "three-blocks/app"; const STATS_PANEL_SIZE: {readonly width: 90; readonly height: 48;} ``` **Purpose:** Declares STATS_PANEL_SIZE as a public value. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for STATS_PANEL_SIZE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### STATS_SCENE_PANEL Kind: variable; canonical: https://threejs-blocks.com/docs/api/STATS_SCENE_PANEL. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { STATS_SCENE_PANEL } from "three-blocks/app"; const STATS_SCENE_PANEL: "scene/color" ``` **Purpose:** Declares STATS_SCENE_PANEL as a public value. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for STATS_SCENE_PANEL. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SceneContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/SceneContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SceneContext } from "three-blocks/app"; interface SceneContext ``` **Purpose:** Declares SceneContext as a public interface. It is exported from three-blocks/app. Its declared surface covers assets and shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SceneContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assets: AssetScope` - `readonly shaders: ShaderSceneCache` ### SceneContextOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SceneContextOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SceneContextOptions } from "three-blocks/app"; interface SceneContextOptions ``` **Purpose:** Declares SceneContextOptions as a public interface. It is exported from three-blocks/app. Its declared surface covers hot. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SceneContextOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly hot?: boolean` ### SceneHotReloader Kind: class; canonical: https://threejs-blocks.com/docs/api/SceneHotReloader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { SceneHotReloader } from "three-blocks/hmr"; class SceneHotReloader, TContext, TState = unknown> ``` **Purpose:** Owns the single scene reference consumed by a render loop and serializes hot updates. A candidate is prepared completely before `current` changes, so failed replacements cannot expose a partially initialized scene. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(initial: TScene, options: SceneHotReloaderOptions)` - `get current(): TScene` - `replace(factory: HotSceneFactory): Promise>` ### SceneHotReloaderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SceneHotReloaderOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SceneHotReloaderOptions } from "three-blocks/hmr"; interface SceneHotReloaderOptions, TContext, TState = unknown> ``` **Purpose:** Declares SceneHotReloaderOptions as a public interface. It is exported from three-blocks/hmr. Its declared surface covers commit, compile, context, pause, and prepare, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SceneHotReloaderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly commit?: (scene: TScene, previous: TScene, context: TContext) => MaybePromise`: Atomically expose the candidate to the renderer while updates remain paused. - `readonly compile?: (scene: TScene, context: TContext) => MaybePromise`: Compile render and compute pipelines before the atomic reference swap. - `readonly context: TContext` - `readonly pause?: () => void`: Optional frame scheduler hooks. `resume` always runs after a matching `pause`. - `readonly prepare?: (scene: TScene, context: TContext) => MaybePromise`: Load newly required resources before the candidate becomes visible. - `readonly resume?: () => void` ### SceneReplacementResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/SceneReplacementResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SceneReplacementResult } from "three-blocks/hmr"; interface SceneReplacementResult ``` **Purpose:** Declares SceneReplacementResult as a public interface. It is exported from three-blocks/hmr. Its declared surface covers cleanupError, current, and previous. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SceneReplacementResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cleanupError?: unknown`: Disposal occurs after commit, so a cleanup failure cannot roll back the new scene. - `readonly current: TScene` - `readonly previous: TScene` ### ScrollState Kind: interface; canonical: https://threejs-blocks.com/docs/api/ScrollState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ScrollState } from "three-blocks/app"; interface ScrollState ``` **Purpose:** Declares ScrollState as a public interface. It is exported from three-blocks/app. Its declared surface covers direction, position, progress, and velocity. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ScrollState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly direction: -1 | 0 | 1` - `readonly position: number` - `readonly progress: number` - `readonly velocity: number` ### SendOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SendOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SendOptions } from "three-blocks/worker"; interface SendOptions ``` **Purpose:** Declares SendOptions as a public interface. It is exported from three-blocks/worker. Its declared surface covers transfer. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SendOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly transfer?: readonly object[]` ### SerializeWorkerErrorOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SerializeWorkerErrorOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SerializeWorkerErrorOptions } from "three-blocks/worker"; interface SerializeWorkerErrorOptions ``` **Purpose:** Declares SerializeWorkerErrorOptions as a public interface. It is exported from three-blocks/worker. Its declared surface covers code, lifecyclePhase, and source. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SerializeWorkerErrorOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code?: string` - `readonly lifecyclePhase: WorkerLifecyclePhase` - `readonly source?: string` ### SerializedShaderValue Kind: type; canonical: https://threejs-blocks.com/docs/api/SerializedShaderValue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SerializedShaderValue } from "three-blocks/shaders"; type SerializedShaderValue = null | boolean | number | string | readonly SerializedShaderValue[] | {readonly [key: string]: SerializedShaderValue;} ``` **Purpose:** Declares SerializedShaderValue as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SerializedShaderValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### SerializedWorkerError Kind: interface; canonical: https://threejs-blocks.com/docs/api/SerializedWorkerError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SerializedWorkerError } from "three-blocks/worker"; interface SerializedWorkerError ``` **Purpose:** Declares SerializedWorkerError as a public interface. It is exported from three-blocks/worker. Its declared surface covers code, lifecyclePhase, message, name, and source, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SerializedWorkerError. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code?: string` - `readonly lifecyclePhase: WorkerLifecyclePhase` - `readonly message: string` - `readonly name: string` - `readonly source?: string` - `readonly stack?: string` ### ShaderAddressContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderAddressContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderAddressContext } from "three-blocks/shaders"; interface ShaderAddressContext ``` **Purpose:** Declares ShaderAddressContext as a public interface. It is exported from three-blocks/shaders. Its declared surface covers anchors, builder, container, key, and kind, plus 8 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderAddressContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly anchors: readonly ShaderAnchor[]` - `builder?: ShaderBindingBuilder` - `readonly container: (key: string) => object | undefined` - `readonly key: string` - `readonly kind: ShaderBuildKind` - `readonly lightsNode: ShaderNodeLike | null` - `readonly material: object | null` - `readonly object: object` - `readonly renderObject?: object`: Active Three.js RenderObject for render builds; absent for compute builds. - `readonly renderer: object` - `readonly scene: object | null` - `readonly sceneKey: string` - `readonly target: object` ### ShaderAddressError Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderAddressError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderAddressError } from "three-blocks/shaders"; class ShaderAddressError extends Error ``` **Purpose:** Declares ShaderAddressError as a public class. It is exported from three-blocks/shaders. Its declared surface covers address and key, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly address: NodeAddress` - `constructor(key: string, address: NodeAddress, reason: string)` - `readonly key: string` ### ShaderAnchor Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderAnchor. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderAnchor } from "three-blocks/shaders"; interface ShaderAnchor ``` **Purpose:** Declares ShaderAnchor as a public interface. It is exported from three-blocks/shaders. Its declared surface covers node and slot. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderAnchor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly node: ShaderNodeLike` - `readonly slot: string` ### ShaderAutomaticRegistrationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderAutomaticRegistrationOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderAutomaticRegistrationOptions } from "three-blocks/shaders"; interface ShaderAutomaticRegistrationOptions ``` **Purpose:** Declares ShaderAutomaticRegistrationOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers prefix and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderAutomaticRegistrationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly prefix?: string`: Human-readable key prefix. Defaults to `auto`. - `readonly scene?: string`: Defaults to the cache's active scene. ### ShaderBackend Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderBackend. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBackend } from "three-blocks/shaders"; type ShaderBackend = 'webgpu' | 'webgl' ``` **Purpose:** Declares ShaderBackend as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBackend. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderBindingBuilder Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderBindingBuilder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBindingBuilder } from "three-blocks/shaders"; interface ShaderBindingBuilder ``` **Purpose:** Declares ShaderBindingBuilder as a public interface. It is exported from three-blocks/shaders. Its declared surface covers context, getBindings, getUniformFromNode, lightsNode, and material, plus 3 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBindingBuilder. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `context?: Record` - `getBindings(): readonly ShaderBindingGroupLike[]` - `getUniformFromNode(node: ShaderNodeLike, type: string, stage: ShaderStage, name: string | null): unknown` - `lightsNode?: ShaderNodeLike | null` - `material?: object | null` - `scene?: object | null` - `shaderStage?: ShaderStage | null` - `sortBindingGroups(): void` ### ShaderBindingGroupLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderBindingGroupLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBindingGroupLike } from "three-blocks/shaders"; interface ShaderBindingGroupLike ``` **Purpose:** Declares ShaderBindingGroupLike as a public interface. It is exported from three-blocks/shaders. Its declared surface covers bindings and name. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBindingGroupLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bindings: readonly ShaderBindingLike[]` - `readonly name: string` ### ShaderBindingLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderBindingLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBindingLike } from "three-blocks/shaders"; interface ShaderBindingLike ``` **Purpose:** Declares ShaderBindingLike as a public interface. It is exported from three-blocks/shaders. Its declared surface covers kind, name, and uniforms, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBindingLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly constructor?: {readonly name?: string;}` - `readonly kind?: string` - `readonly name: string` - `readonly uniforms?: readonly ShaderUniformBindingLike[]` ### ShaderBuildKind Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderBuildKind. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBuildKind } from "three-blocks/shaders"; type ShaderBuildKind = 'render' | 'compute' ``` **Purpose:** Declares ShaderBuildKind as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBuildKind. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderBuildState Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderBuildState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderBuildState } from "three-blocks/shaders"; interface ShaderBuildState ``` **Purpose:** Declares ShaderBuildState as a public interface. It is exported from three-blocks/shaders. Its declared surface covers changedKeys, reason, state, and strict. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderBuildState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changedKeys?: readonly string[]`: Key-level changes when the Vite dependency graph can identify them safely. - `readonly reason?: string` - `readonly state: ShaderManifestState` - `readonly strict?: boolean` ### ShaderCache Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderCache. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderCache } from "three-blocks/shaders"; class ShaderCache ``` **Purpose:** Stable, scene-scoped shader registration. No renderer or Vite hooks are installed by construction; worker setup opts into those through `installShaderCache()`. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and compute. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `activateScene(scene: string): ShaderSceneCache` - `get activeScene(): string` - `automaticRegistrationPrefix(scene?: string): string | undefined`: Prefix currently governing deterministic automatic keys for one scene. - `compute(key: string, computeNode: object, options?: ShaderRegistrationOptions): ShaderRegistrationHandle` - `constructor(activeScene?: string)` - `container(key: string, container: object, options?: ShaderRegistrationOptions): ShaderRegistrationHandle` - `containerFor(key: string, scene?: string): object | undefined` - `containers(scene?: string): readonly ShaderContainerRegistration[]`: Read-only capture view of explicitly registered non-node containers. - `coverage(manifest: PrecompiledManifest, scene?: string): ShaderCoverage` - `enableAutomaticRegistration(options?: ShaderAutomaticRegistrationOptions): void`: Opt a scene into deterministic build-order registrations. - `forScene(scene: string, options?: ShaderSceneCacheOptions): ShaderSceneCache` - `invalidateKey(key: string, reason?: string, scene?: string): void` - `invalidateScene(scene?: string, reason?: string): void` - `invalidationFor(key: string, scene?: string): ShaderInvalidation | undefined` - `material(key: string, material: object, options?: ShaderRegistrationOptions): ShaderRegistrationHandle` - `pipeline(key: string, pipeline: object, options?: ShaderRegistrationOptions): ShaderRegistrationHandle` - `post(key: string, pipeline: object, options?: ShaderRegistrationOptions): ShaderRegistrationHandle`: Compatibility spelling for the integration lab's former `post()` API. - `registration(key: string, scene?: string): ShaderRegistration | undefined` - `registrationForCompute(computeNode: object, scene?: string): ShaderRegistration | undefined` - `registrationForRender(material: object, scene?: string, renderObject?: object): ShaderRegistration | undefined` - `registrations(scene?: string): readonly ShaderRegistration[]` ### ShaderCacheProvider Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderCacheProvider. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderCacheProvider } from "three-blocks/shaders"; class ShaderCacheProvider implements ShaderProviderHook ``` **Purpose:** Provider consulted on renderer cache misses by the version-gated Vite hook. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(options: ShaderCacheProviderOptions)` - `getForCompute(computeNode: object): BuilderStateTuple | null` - `getForCompute(computeNode: object, NodeBuilderState: ShaderNodeBuilderStateConstructor, prepareForHydration?: () => void): object | null` - `getForRender(renderObject: ShaderRenderObjectLike): BuilderStateTuple | null` - `getForRender(renderObject: ShaderRenderObjectLike, NodeBuilderState: ShaderNodeBuilderStateConstructor, prepareForHydration?: () => void): object | null` - `invalidateKey(key: string, reason?: string): void` - `invalidateScene(reason?: string): void` - `get manifest(): PrecompiledManifest` - `get stats(): ShaderRuntimeStats` ### ShaderCacheProviderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderCacheProviderOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderCacheProviderOptions } from "three-blocks/shaders"; interface ShaderCacheProviderOptions ``` **Purpose:** Declares ShaderCacheProviderOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers cache, compatibility, logger, manifest, and renderer, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderCacheProviderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cache?: ShaderCache` - `readonly compatibility: ShaderCompatibility` - `readonly logger?: ShaderRuntimeLogger` - `readonly manifest: PrecompiledManifest` - `readonly renderer: object` - `readonly strict?: boolean`: Throw ShaderHydrationError into the renderer when a manifest state fails to hydrate. Off by default: production applications log the failure once and fall back to live TSL compilation for that key instead of breaking rendering. ### ShaderCaptureCacheHook Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderCaptureCacheHook. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderCaptureCacheHook } from "three-blocks/shaders"; type ShaderCaptureCacheHook = (cache: ShaderCache) => void ``` **Purpose:** Declares ShaderCaptureCacheHook as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderCaptureCacheHook. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderCompatibility Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderCompatibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderCompatibility } from "three-blocks/shaders"; interface ShaderCompatibility ``` **Purpose:** All Three.js-private behavior is centralized behind this versioned adapter. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderCompatibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `anchorsFor(target: object, kind: ShaderBuildKind): readonly ShaderAnchor[]` - `bindingKind?(binding: ShaderBindingLike): string` - `cloneBindingNode?(node: ShaderNodeLike, address: NodeAddress, instance: number, context: ShaderAddressContext): ShaderNodeLike`: Materialize a distinct binding node when capture observed multiple node identities at one semantic address. - `createAttribute?(name: string, type: string, node: ShaderNodeLike | null, builder: ShaderBindingBuilder): unknown` - `createBindingBuilder(context: ShaderAddressContext): ShaderBindingBuilder` - `createObserver?(observer: PrecompiledObserver | null, context: ShaderAddressContext): unknown` - `getBindings?(builder: ShaderBindingBuilder, context: ShaderAddressContext): readonly ShaderBindingGroupLike[]`: Finalize binding groups without colliding with another hydrated shader layout. - `hasFeature?(renderer: object, feature: string): boolean` - `readonly id: string` - `installProvider(renderer: object, provider: ShaderProviderHook): () => void` - `primeBindingNode?(node: ShaderNodeLike, builder: ShaderBindingBuilder): void` - `primeOwnedAddress?(node: ShaderNodeLike, context: ShaderAddressContext): void` - `primePrecompiledObject?(object: object): void`: Materialize object state that Three normally creates after precompiled setup begins. - `resolveRecipeAddress(address: Exclude, context: ShaderAddressContext): ShaderNodeLike` - `supportsManifest(manifest: PrecompiledManifest): boolean` - `supportsRenderer(renderer: object): boolean` - `readonly threeVersion: string` - `unsupportedState?(state: PrecompiledState, manifest: PrecompiledManifest): string | null`: Return a reason when this backend must leave one captured state on the live path. ### ShaderContainerRegistration Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderContainerRegistration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderContainerRegistration } from "three-blocks/shaders"; interface ShaderContainerRegistration ``` **Purpose:** Declares ShaderContainerRegistration as a public interface. It is exported from three-blocks/shaders. Its declared surface covers key, scene, and target. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderContainerRegistration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly key: string` - `readonly scene: string` - `readonly target: object` ### ShaderCoverage Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderCoverage. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderCoverage } from "three-blocks/shaders"; interface ShaderCoverage ``` **Purpose:** Declares ShaderCoverage as a public interface. It is exported from three-blocks/shaders. Its declared surface covers covered, coveredCompute, coveredRender, extra, and manifest, plus 6 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderCoverage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly covered: number` - `readonly coveredCompute: number` - `readonly coveredRender: number` - `readonly extra: readonly string[]` - `readonly manifest: number` - `readonly manifestCompute: number` - `readonly manifestRender: number` - `readonly missing: readonly string[]` - `readonly registered: number` - `readonly registeredCompute: number` - `readonly registeredRender: number` ### ShaderHydrationError Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderHydrationError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderHydrationError } from "three-blocks/shaders"; class ShaderHydrationError extends Error ``` **Purpose:** Declares ShaderHydrationError as a public class. It is exported from three-blocks/shaders. Its declared surface covers causeValue, key, kind, and scene, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly causeValue: unknown` - `constructor(scene: string, key: string, kind: ShaderBuildKind, causeValue: unknown)` - `readonly key: string` - `readonly kind: ShaderBuildKind` - `readonly scene: string` ### ShaderInvalidation Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderInvalidation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderInvalidation } from "three-blocks/shaders"; interface ShaderInvalidation ``` **Purpose:** Declares ShaderInvalidation as a public interface. It is exported from three-blocks/shaders. Its declared surface covers key, reason, and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderInvalidation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly key?: string` - `readonly reason: string` - `readonly scene: string` ### ShaderManifestError Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderManifestError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderManifestError } from "three-blocks/shaders"; class ShaderManifestError extends Error ``` **Purpose:** Declares ShaderManifestError as a public class. It is exported from three-blocks/shaders. Its declared surface covers issues, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(message: string, issues: readonly ShaderManifestIssue[])` - `readonly issues: readonly ShaderManifestIssue[]` ### ShaderManifestIssue Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderManifestIssue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderManifestIssue } from "three-blocks/shaders"; interface ShaderManifestIssue ``` **Purpose:** Declares ShaderManifestIssue as a public interface. It is exported from three-blocks/shaders. Its declared surface covers message and path. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderManifestIssue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly message: string` - `readonly path: string` ### ShaderManifestState Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderManifestState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderManifestState } from "three-blocks/shaders"; type ShaderManifestState = 'fresh' | 'stale' | 'invalid' | 'missing' | 'not-observed' ``` **Purpose:** Declares ShaderManifestState as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderManifestState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderManifestValidation Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderManifestValidation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderManifestValidation } from "three-blocks/shaders"; type ShaderManifestValidation = {readonly ok: true; readonly manifest: PrecompiledManifest;} | {readonly ok: false; readonly issues: readonly ShaderManifestIssue[];} ``` **Purpose:** Declares ShaderManifestValidation as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderManifestValidation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderNodeChild Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderNodeChild. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderNodeChild } from "three-blocks/shaders"; interface ShaderNodeChild ``` **Purpose:** Declares ShaderNodeChild as a public interface. It is exported from three-blocks/shaders. Its declared surface covers childNode. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderNodeChild. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly childNode: ShaderNodeLike` ### ShaderNodeLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderNodeLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderNodeLike } from "three-blocks/shaders"; interface ShaderNodeLike ``` **Purpose:** Deliberately small structural view of a Three.js node. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderNodeLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `getSerializeChildren?(): Iterable` - `id?: number` - `readonly isNode?: boolean` ### ShaderPathSegment Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderPathSegment. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderPathSegment } from "three-blocks/shaders"; type ShaderPathSegment = string | number ``` **Purpose:** Declares ShaderPathSegment as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderPathSegment. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderProviderHook Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderProviderHook. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderProviderHook } from "three-blocks/shaders"; interface ShaderProviderHook ``` **Purpose:** Declares ShaderProviderHook as a public interface. It is exported from three-blocks/shaders. Its declared surface covers getForCompute and getForRender, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderProviderHook. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `getForCompute(computeNode: object): BuilderStateTuple | null` - `getForCompute(computeNode: object, NodeBuilderState: ShaderNodeBuilderStateConstructor, prepareForHydration?: () => void): object | null` - `getForRender(renderObject: ShaderRenderObjectLike): BuilderStateTuple | null` - `getForRender(renderObject: ShaderRenderObjectLike, NodeBuilderState: ShaderNodeBuilderStateConstructor, prepareForHydration?: () => void): object | null` ### ShaderProviderInstallError Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderProviderInstallError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderProviderInstallError } from "three-blocks/shaders"; class ShaderProviderInstallError extends Error ``` **Purpose:** Declares ShaderProviderInstallError as a public class. It is exported from three-blocks/shaders. Its declared surface covers causeValue and state, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly causeValue: unknown` - `constructor(state: ShaderBuildState['state'], reason: string, causeValue?: unknown)` - `readonly state: ShaderBuildState['state']` ### ShaderProviderInstallation Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderProviderInstallation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderProviderInstallation } from "three-blocks/shaders"; interface ShaderProviderInstallation ``` **Purpose:** Declares ShaderProviderInstallation as a public interface. It is exported from three-blocks/shaders. Its declared surface covers dispose, mode, provider, reason, and runtimeStats, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(): void` - `readonly mode: 'precompiled' | 'live'` - `readonly provider?: ShaderCacheProvider` - `readonly reason: string` - `readonly runtimeStats?: ShaderRuntimeStats`: Dynamic counters for either a precompiled provider or an observed live fallback. - `readonly scene: string` - `readonly state: ShaderBuildState['state']` ### ShaderRegistration Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderRegistration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRegistration } from "three-blocks/shaders"; interface ShaderRegistration ``` **Purpose:** Declares ShaderRegistration as a public interface. It is exported from three-blocks/shaders. Its declared surface covers automatic, key, kind, owner, and scene, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRegistration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly automatic?: boolean`: True only for registrations synthesized by gallery/devtools discovery. - `readonly key: string` - `readonly kind: ShaderRegistrationKind` - `readonly owner: object`: Original pipeline for pipeline registrations; otherwise the target. - `readonly scene: string` - `readonly target: object`: Material for render registrations, compute root for compute registrations. ### ShaderRegistrationHandle Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderRegistrationHandle. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRegistrationHandle } from "three-blocks/shaders"; interface ShaderRegistrationHandle ``` **Purpose:** Declares ShaderRegistrationHandle as a public interface. It is exported from three-blocks/shaders. Its declared surface covers dispose, key, kind, and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(): void` - `readonly key: string` - `readonly kind: ShaderRegistrationKind | 'container'` - `readonly scene: string` ### ShaderRegistrationKind Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderRegistrationKind. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRegistrationKind } from "three-blocks/shaders"; type ShaderRegistrationKind = 'material' | 'pipeline' | 'compute' ``` **Purpose:** Declares ShaderRegistrationKind as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRegistrationKind. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderRegistrationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderRegistrationOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRegistrationOptions } from "three-blocks/shaders"; interface ShaderRegistrationOptions ``` **Purpose:** Declares ShaderRegistrationOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers replace and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRegistrationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly replace?: boolean`: Explicit HMR replacement. Replacements invalidate this key for the session. - `readonly scene?: string`: Defaults to the cache's active scene. ### ShaderRenderObjectLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderRenderObjectLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRenderObjectLike } from "three-blocks/shaders"; interface ShaderRenderObjectLike ``` **Purpose:** Declares ShaderRenderObjectLike as a public interface. It is exported from three-blocks/shaders. Its declared surface covers lightsNode, material, object, and scene. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRenderObjectLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly lightsNode?: ShaderNodeLike | null` - `readonly material: object` - `readonly object: object` - `readonly scene?: object | null` ### ShaderRuntimeLogger Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderRuntimeLogger. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRuntimeLogger } from "three-blocks/shaders"; type ShaderRuntimeLogger = (level: 'info' | 'warn' | 'error', message: string) => void ``` **Purpose:** Declares ShaderRuntimeLogger as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRuntimeLogger. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderRuntimeStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderRuntimeStats. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderRuntimeStats } from "three-blocks/shaders"; interface ShaderRuntimeStats extends ShaderCoverage ``` **Purpose:** Declares ShaderRuntimeStats as a public interface. It is exported from three-blocks/shaders. Its declared surface covers computeLookups, hydrationFailures, hydrationMs, injected, and injectedCompute, plus 11 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderRuntimeStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly computeLookups: number` - `readonly hydrationFailures: number` - `readonly hydrationMs: number`: Total synchronous declaration/binding replay time. - `readonly injected: number` - `readonly injectedCompute: number` - `readonly injectedRender: number` - `readonly invalidated: number` - `readonly live: number` - `readonly liveCompute: number` - `readonly liveRender: number` - `readonly lookups: number`: Number of times transformed Three.js consulted this provider. - `readonly maxHydrationMs: number`: Longest single synchronous declaration/binding replay call. - `readonly missed: number` - `readonly missedCompute: number` - `readonly missedRender: number` - `readonly renderLookups: number` ### ShaderSceneCache Kind: class; canonical: https://threejs-blocks.com/docs/api/ShaderSceneCache. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ShaderSceneCache } from "three-blocks/shaders"; class ShaderSceneCache ``` **Purpose:** Scene-local convenience facade. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and compute. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `compute(key: string, computeNode: object, options?: Omit): ShaderRegistrationHandle` - `constructor(cache: ShaderCache, scene: string, options?: ShaderSceneCacheOptions)` - `container(key: string, container: object, options?: Omit): ShaderRegistrationHandle` - `invalidate(reason?: string): void` - `invalidateKey(key: string, reason?: string): void` - `material(key: string, material: object, options?: Omit): ShaderRegistrationHandle` - `pipeline(key: string, pipeline: object, options?: Omit): ShaderRegistrationHandle` - `readonly scene: string` ### ShaderSceneCacheOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderSceneCacheOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderSceneCacheOptions } from "three-blocks/shaders"; interface ShaderSceneCacheOptions ``` **Purpose:** Declares ShaderSceneCacheOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers replaceExisting. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderSceneCacheOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly replaceExisting?: boolean`: Replace registrations left by the previous scene on each key's first use. ### ShaderStage Kind: type; canonical: https://threejs-blocks.com/docs/api/ShaderStage. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderStage } from "three-blocks/shaders"; type ShaderStage = 'vertex' | 'fragment' | 'compute' ``` **Purpose:** Declares ShaderStage as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderStage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ShaderUniformBindingLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/ShaderUniformBindingLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ShaderUniformBindingLike } from "three-blocks/shaders"; interface ShaderUniformBindingLike ``` **Purpose:** Declares ShaderUniformBindingLike as a public interface. It is exported from three-blocks/shaders. Its declared surface covers getType and name. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ShaderUniformBindingLike. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `getType?(): unknown` - `readonly name: string` ### SkinnedMeshSDF Kind: variable; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDF. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SkinnedMeshSDF } from "three-blocks/sdf-raymarching"; const SkinnedMeshSDF: SkinnedMeshSDFConstructor ``` **Purpose:** Live signed-distance and surface-velocity field rebuilt from a skinned mesh's actual triangles, entirely on the GPU, every frame. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. - `collide(options: SkinnedMeshSDFCollideOptions): THREE.Node<'vec3'>`: Complete collision response for simulation hooks: sample, tetrahedral contact normal, friction and restitution against the surface's own velocity, and penetration push-out. Returns the corrected world-space velocity. - `new (skinnedMesh: THREE.SkinnedMesh, options?: SkinnedMeshSDFOptions): SkinnedMeshSDF`: Build the complete compute graph for one indexed, skinned mesh. - `dispatch(renderer: THREE.Renderer): void`: Submit the complete field rebuild to the renderer. - `dispose(): void`: Release the owned texture, storage buffers, and compute passes. - `distance(worldPosition: SkinnedMeshSDFSamplePosition): THREE.Node<'float'>`: Signed distance from a world position to the tracked surface. - `readonly domain: THREE.Vector3`: World-space size of the field domain. - `gradient(worldPosition: SkinnedMeshSDFSamplePosition): THREE.Node<'vec3'>`: Tetrahedral field gradient at a world position; normalize it for a contact normal. - `readonly positionBuffer: THREE.StorageBufferNode<'vec4'>`: Skinned world-space vertex positions, one vec4 per vertex. - `readonly resolution: number`: Cubic voxel dimension of the field. - `sample(worldPosition: SkinnedMeshSDFSamplePosition): THREE.Node<'vec4'>`: Sample the field at a world position: surface velocity xyz, signed distance w. - `readonly sdfToWorldMatrix: THREE.Matrix4`: Mutable normalized-field to world transform, refreshed by setDomainCenter. - `setDomainCenter(center: THREE.Vector3): void`: Recenter the axis-aligned field domain around a world-space point. - `surfaceVelocity(worldPosition: SkinnedMeshSDFSamplePosition): THREE.Node<'vec3'>`: Interpolated surface velocity of the nearest tracked surface point. - `readonly texture: SDFTextureOutput`: Owned rgba16float collider texture: surface velocity xyz, signed distance w. - `readonly uniforms: SkinnedMeshSDFUniforms`: Owned uniform nodes shared by every pass and external sampler. - `update(dt: number, center?: THREE.Vector3): void`: Refresh skeleton, transform, and timestep state before a dispatch. - `readonly velocityBuffer: THREE.StorageBufferNode<'vec4'>`: Clamped world-space vertex velocities, one vec4 per vertex. - `readonly voxelSize: THREE.Vector3`: World-space size of one voxel per axis. - `readonly voxelStep: number`: Smallest voxel edge; the distance step used during propagation. - `readonly worldToSdfMatrix: THREE.Matrix4`: Mutable world to normalized-field transform, refreshed by setDomainCenter. ### SkinnedMeshSDFCollideOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDFCollideOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SkinnedMeshSDFCollideOptions } from "three-blocks/sdf-raymarching"; interface SkinnedMeshSDFCollideOptions ``` **Purpose:** Per-particle configuration for SkinnedMeshSDF.collide. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SkinnedMeshSDFCollideOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `deepEscape?: SkinnedMeshSDFScalar | undefined`: Maximum blend toward a domain-radial escape normal for deep penetrations; zero keeps the raw gradient. - `friction?: SkinnedMeshSDFScalar | undefined`: Fraction of tangential velocity removed on contact; zero slides freely. - `maxPushOutSpeed?: SkinnedMeshSDFScalar | undefined`: Cap on the push-out separation speed, in world units per second. - `position: SkinnedMeshSDFSamplePosition`: World-space particle position. - `pushOutRate?: SkinnedMeshSDFScalar | undefined`: Separation speed gained per meter of penetration. - `radius?: SkinnedMeshSDFScalar | undefined`: Particle radius; the response triggers when signed distance drops below it. - `restitution?: SkinnedMeshSDFScalar | undefined`: Fraction of approach speed reflected on contact; zero absorbs the impact. - `velocity: SkinnedMeshSDFSamplePosition`: World-space particle velocity entering the response. ### SkinnedMeshSDFOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDFOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SkinnedMeshSDFOptions } from "three-blocks/sdf-raymarching"; interface SkinnedMeshSDFOptions ``` **Purpose:** Construction configuration for SkinnedMeshSDF. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SkinnedMeshSDFOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `bandVoxels?: number | undefined`: Exact-distance band half-width around the surface, in voxels. - `domain?: THREE.Vector3 | undefined`: World-space size of the axis-aligned field domain. - `far?: number | undefined`: Signed distance written where no surface information exists. - `maxSurfaceSpeed?: number | undefined`: Upper clamp applied to per-vertex surface velocity, in world units per second. - `propagationPasses?: number | undefined`: Ping-pong distance-propagation passes; each extends coverage by one voxel. - `resolution?: number | undefined`: Cubic voxel dimension of the field; work and memory grow with its cube. ### SkinnedMeshSDFSamplePosition Kind: type; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDFSamplePosition. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SkinnedMeshSDFSamplePosition } from "three-blocks/sdf-raymarching"; type SkinnedMeshSDFSamplePosition = THREE.Node<'vec3'> | THREE.Vector3 ``` **Purpose:** World-space position accepted by the SkinnedMeshSDF sampling helpers. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SkinnedMeshSDFSamplePosition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### SkinnedMeshSDFScalar Kind: type; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDFScalar. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SkinnedMeshSDFScalar } from "three-blocks/sdf-raymarching"; type SkinnedMeshSDFScalar = THREE.Node<'float'> | number ``` **Purpose:** Scalar response parameter: a plain number or any float-producing TSL node. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SkinnedMeshSDFScalar. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### SkinnedMeshSDFUniforms Kind: interface; canonical: https://threejs-blocks.com/docs/api/SkinnedMeshSDFUniforms. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SkinnedMeshSDFUniforms } from "three-blocks/sdf-raymarching"; interface SkinnedMeshSDFUniforms ``` **Purpose:** TSL uniform nodes owned and refreshed by a SkinnedMeshSDF instance. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SkinnedMeshSDFUniforms. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. - `readonly band: THREE.UniformNode<'float', number>`: Exact-distance band half-width in world units. - `readonly dt: THREE.UniformNode<'float', number>`: Timestep used for surface-velocity estimation. - `readonly far: THREE.UniformNode<'float', number>`: Signed distance reported where no surface information exists. - `readonly sdfToWorld: THREE.UniformNode<'mat4', THREE.Matrix4>`: Normalized-field to world transform. - `readonly voxelSize: THREE.UniformNode<'vec3', THREE.Vector3>`: World-space size of one voxel per axis. - `readonly worldToSdf: THREE.UniformNode<'mat4', THREE.Matrix4>`: World to normalized-field transform. ### SmokeBridgeSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeBridgeSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { SmokeBridgeSource } from "three-blocks/app"; interface SmokeBridgeSource ``` **Purpose:** Structural source accepted by the browser-smoke global installer. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeBridgeSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly readiness: ThreeBlocksReadiness` - `readonly smoke: ThreeBlocksSmokeState` ### SmokeDomainBindingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeDomainBindingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeDomainBindingOptions } from "three-blocks/smoke"; interface SmokeDomainBindingOptions ``` **Purpose:** Domain-object binding controls. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeDomainBindingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `autoUpdate?: boolean | undefined`: Re-read the object's world matrix before every simulation step. ### SmokeMultigridPreset Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeMultigridPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeMultigridPreset } from "three-blocks/smoke"; type SmokeMultigridPreset = 'quality' | 'balanced' ``` **Purpose:** Coherent multigrid tuning profile selected before explicit overrides. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeMultigridPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeNodePointerInput Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeNodePointerInput. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeNodePointerInput } from "three-blocks/smoke"; type SmokeNodePointerInput = Vector2 | null ``` **Purpose:** Pointer input accepted by the compact 2D smoke-node factory. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeNodePointerInput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeNodeResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeNodeResult. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeNodeResult } from "three-blocks/smoke"; interface SmokeNodeResult extends Node ``` **Purpose:** TSL node returned by smoke. The node owns its simulation textures and automatically submits its per-frame update before dependent rendering. Its scalar setters are safe between frames. Call SmokeNodeResult.dispose after detaching the node from every material. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `dispose(): void`: Release factory-owned render targets, storage textures, and helper materials. - `setPointerScale(scale: number): this`: Change pointer-motion amplification used by later automatic updates. - `setPressureIterations(iterations: number): this`: Change pressure-projection iterations used by later automatic updates. - `setSpeedFactor(value: number): this`: Change the simulation-time multiplier used by later automatic updates. ### SmokePressureSolver Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokePressureSolver. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokePressureSolver } from "three-blocks/smoke"; type SmokePressureSolver = 'sor' | 'multigrid' ``` **Purpose:** Pressure projection algorithm used by the volume solver. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokePressureSolver. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokePressureSolverOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokePressureSolverOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokePressureSolverOptions } from "three-blocks/smoke"; interface SmokePressureSolverOptions ``` **Purpose:** Multigrid overrides accepted when changing pressure solvers. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokePressureSolverOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `autoTune?: boolean | undefined`: Allow the solver to adjust correction scales from the selected preset. - `coarseIterations?: number | undefined`: Relaxation sweeps at the coarsest level. - `correctionScale?: number | undefined`: Scale applied to fine-grid correction. - `cycles?: number | undefined`: V-cycles submitted per pressure solve. - `maxLevels?: number | undefined`: Maximum number of multigrid levels. - `minResolution?: number | undefined`: Smallest allowed multigrid resolution. - `postSmooth?: number | undefined`: Relaxation sweeps after correction prolongation. - `preSmooth?: number | undefined`: Relaxation sweeps before residual restriction. - `preset?: SmokeMultigridPreset | undefined`: Coherent multigrid starting profile. - `recursiveCorrectionScale?: number | undefined`: Scale applied to recursive coarse-grid correction. ### SmokeRenderCacheOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeRenderCacheOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeRenderCacheOptions } from "three-blocks/smoke"; interface SmokeRenderCacheOptions ``` **Purpose:** Render-cache refresh policy for a smoke step or explicit refresh. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeRenderCacheOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `lightOpticalDepth?: boolean | undefined`: Refresh or maintain the light optical-depth texture. - `occupancy?: boolean | undefined`: Refresh or maintain the occupancy acceleration texture. ### SmokeSplatBlendMode Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeSplatBlendMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeSplatBlendMode } from "three-blocks/smoke"; type SmokeSplatBlendMode = 'add' | 'inflow' ``` **Purpose:** Blend operation used by density and velocity splats. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeSplatBlendMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeSplatExecutionPath Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeSplatExecutionPath. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeSplatExecutionPath } from "three-blocks/smoke"; type SmokeSplatExecutionPath = Exclude | 'none' ``` **Purpose:** Dispatch path reported for the most recent source upload. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeSplatExecutionPath. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeSplatMode Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeSplatMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeSplatMode } from "three-blocks/smoke"; type SmokeSplatMode = 'auto' | 'batched' | 'sparse' | 'sequential' ``` **Purpose:** Dispatch strategy used for queued density and velocity sources. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeSplatMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeSplatOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeSplatOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeSplatOptions } from "three-blocks/smoke"; interface SmokeSplatOptions ``` **Purpose:** Options for one world-space smoke injection. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeSplatOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `densityBlend?: number | undefined`: Density interpolation weight used by `inflow` mode. - `densityMode?: SmokeSplatBlendMode | undefined`: Density blend operation. - `radius?: number | undefined`: Source radius in normalized volume coordinates. - `temperatureAmount?: number | undefined`: Temperature injected with density; defaults to the density amount. - `velocityBlend?: number | undefined`: Velocity interpolation weight used by `inflow` mode. - `velocityMode?: SmokeSplatBlendMode | undefined`: Velocity blend operation. ### SmokeSplatStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeSplatStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeSplatStats } from "three-blocks/smoke"; interface SmokeSplatStats ``` **Purpose:** Statistics for the splat stage of the most recent smoke step. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeSplatStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `readonly copies: number`: GPU copies requested while uploading sources. - `readonly cpuSubmissionMs: number`: CPU time spent preparing and submitting sources, in milliseconds. - `readonly dispatches: number`: Compute dispatches submitted for sources. - `readonly path: SmokeSplatExecutionPath`: Dispatch path selected for those sources. - `readonly sourceCount: number`: Number of queued sources consumed by the step. - `readonly submissions: number`: Renderer compute submissions used for sources. - `readonly touchedVoxelEstimate: number`: Approximate number of voxels touched by sparse dispatch. - `readonly uploadBytes: number`: Bytes uploaded for source data. - `readonly uploadMs: number`: CPU upload time, in milliseconds. ### SmokeStepOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeStepOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeStepOptions } from "three-blocks/smoke"; interface SmokeStepOptions ``` **Purpose:** Per-frame smoke scheduling controls. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeStepOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `refreshRenderCaches?: boolean | SmokeRenderCacheOptions | undefined`: Refresh all enabled caches, select individual caches, or skip refreshes. ### SmokeStepStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeStepStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeStepStats } from "three-blocks/smoke"; interface SmokeStepStats ``` **Purpose:** Read-only scheduling snapshot for the most recent smoke step. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeStepStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `readonly coarsePressureSweeps: number`: Coarser-grid pressure relaxation sweeps. - `readonly dispatches: number`: Total compute dispatches submitted by the step. - `readonly finePressureSweeps: number`: Finest-grid pressure relaxation sweeps. - `readonly multigridCycles: number`: Multigrid V-cycles submitted by the step. - `readonly multigridLevels: number`: Multigrid levels visited by the step. - `readonly multigridPreset?: SmokeMultigridPreset | null | undefined`: Multigrid profile, or `null` for SOR projection. - `readonly pressureSolver: SmokePressureSolver`: Pressure solver used by the step. - `readonly pressureSweeps: number`: Aggregate pressure relaxation sweeps. - `readonly sources: Readonly`: Source-stage statistics. - `readonly submissions: number`: Total renderer compute submissions used by the step. - `readonly turbulenceFieldRefreshed?: boolean | undefined`: Whether the step rebuilt its turbulence field. - `readonly turbulenceMode: SmokeTurbulenceMode`: Turbulence resolution policy used by the step. - `readonly turbulenceResolution: number`: Cubic resolution of the turbulence field. ### SmokeTurbulenceMode Kind: type; canonical: https://threejs-blocks.com/docs/api/SmokeTurbulenceMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeTurbulenceMode } from "three-blocks/smoke"; type SmokeTurbulenceMode = 'low-resolution' | 'full-resolution' ``` **Purpose:** Resolution policy used for the turbulence field. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeTurbulenceMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### SmokeVolume Kind: variable; canonical: https://threejs-blocks.com/docs/api/SmokeVolume. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SmokeVolume } from "three-blocks/smoke"; const SmokeVolume: SmokeVolumeConstructor ``` **Purpose:** Stable 3D smoke-solver facade. The solver owns every returned storage texture. Construct it before the render material, call SmokeVolume.initialize once, queue world splats, call SmokeVolume.step, and only then render consumers of its textures. Invalid resolutions, unsupported pressure choices, missing renderer capabilities, and use after resource teardown can throw. Dispose the material before this solver, then call SmokeVolume.dispose after all texture consumers are detached. Runtime-identical constructor for the narrow stable smoke-volume facade. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, initialize, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. - `addWorldSplat(worldPosition: Vector3, worldVelocity?: Vector3 | null, densityAmount?: number, options?: SmokeSplatOptions): this`: Queue a density, temperature, and optional velocity source in world space. - `new (options?: SmokeVolumeOptions): SmokeVolume`: Create a stable smoke simulation with optional solver and resolution controls. - `dispose(): void`: Release all solver-owned textures and compute resources after consumers detach. - `readonly dyeRes: number`: Cubic density-grid resolution fixed at construction. - `getCurlTexture3D(): Storage3DTexture`: Solver-owned curl texture sampled by flow-detail materials. - `getDensityTexture3D(): Storage3DTexture`: Solver-owned density and temperature texture sampled by smoke materials. - `getLastStepStats(): Readonly`: Return an immutable view of the most recently completed step statistics. - `getLightOpticalDepthTexture3D(): Storage3DTexture`: Solver-owned cached light optical-depth texture. - `getOccupancyGridSize(target?: Vector3): Vector3`: Copy the current occupancy-grid dimensions into a caller-owned vector. - `getOccupancyTexture3D(): Storage3DTexture`: Solver-owned occupancy texture used for empty-space skipping. - `getVelocityTexture3D(): Storage3DTexture`: Solver-owned velocity texture sampled by flow-detail materials. - `initialize(renderer: Renderer): this`: Allocate and clear renderer-backed state before the first simulation step. - `refreshRenderCaches(renderer: Renderer, options?: SmokeRenderCacheOptions): this`: Rebuild selected render caches after simulation and before rendering. - `setBuoyancyDirection(direction: Vector3): this`: Copy the world-space direction used for thermal buoyancy. - `setDomainFromObject(object: Object3D, options?: SmokeDomainBindingOptions): this`: Bind the unit volume to a caller-owned object's world transform. - `setDomainTransform(matrixWorld: Matrix4): this`: Copy an explicit world transform into the volume mapping. - `setLightDirection(direction: Vector3): this`: Copy the world-space direction used by cached smoke lighting. - `setPressureSolver(solver: SmokePressureSolver, options?: SmokePressureSolverOptions): this`: Change pressure projection for later steps; invalid settings throw. - `readonly simRes: number`: Cubic velocity-grid resolution fixed at construction. - `step(renderer: Renderer, dt?: number, options?: SmokeStepOptions): this`: Submit one simulation step after sources and transforms are updated. - `syncDomainTransform(force?: boolean): this`: Refresh an auto-bound domain after its object transform changes. ### SmokeVolumeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/SmokeVolumeOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SmokeVolumeOptions } from "three-blocks/smoke"; interface SmokeVolumeOptions ``` **Purpose:** Intentional construction controls for the stable 3D smoke solver. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SmokeVolumeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `buoyancyDirection?: Vector3 | undefined`: World-space buoyancy direction. - `buoyancyStrength?: number | undefined`: Buoyancy acceleration applied to hot smoke. - `curlStrength?: number | undefined`: Vorticity-confinement strength. - `densityAdvectionCorrection?: number | undefined`: MacCormack density-correction strength. - `densityDiffusion?: number | undefined`: Density diffusion strength. - `densityDissipation?: number | undefined`: Density retained by one reference simulation interval. - `densityWeight?: number | undefined`: Density contribution that opposes thermal buoyancy. - `dyeRes?: number | undefined`: Cubic density-grid resolution. - `enableLightOpticalDepthCache?: boolean | undefined`: Whether cached light optical depth is maintained. - `enableOccupancyCache?: boolean | undefined`: Whether the occupancy acceleration texture is maintained. - `iterations?: number | undefined`: Pressure sweeps used by the selected solver. - `lightDirection?: Vector3 | undefined`: World-space direction toward the primary light. - `lightRes?: number | undefined`: Cubic resolution of the cached light field. - `lightSteps?: number | undefined`: Integration steps used by cached light optical depth. - `maxSplatSources?: number | undefined`: Maximum number of splat sources accepted per submission. - `multigridCycles?: number | undefined`: V-cycles submitted by each multigrid pressure solve. - `multigridPreset?: SmokeMultigridPreset | undefined`: Coherent starting profile for multigrid projection. - `pressureDissipation?: number | undefined`: Pressure retained between solves. - `pressureSolver?: SmokePressureSolver | undefined`: Pressure projection algorithm. - `simRes?: number | undefined`: Cubic velocity-grid resolution. - `speedFactor?: number | undefined`: Simulation-speed multiplier applied to host-frame deltas. - `splatMode?: SmokeSplatMode | undefined`: Source dispatch strategy. - `temperatureDissipation?: number | undefined`: Temperature retained by one reference simulation interval. - `turbulenceFrequency?: number | undefined`: Procedural turbulence spatial frequency. - `turbulenceMode?: SmokeTurbulenceMode | undefined`: Resolution policy for procedural turbulence. - `turbulenceOctaves?: number | undefined`: Number of turbulence noise octaves. - `turbulenceSpeed?: number | undefined`: Procedural turbulence animation speed. - `turbulenceStrength?: number | undefined`: Procedural turbulence amplitude. - `turbulenceUpdateInterval?: number | undefined`: Number of solver steps between turbulence-field refreshes. - `useBoundaries?: boolean | undefined`: Whether box-domain boundary conditions are enabled. - `velocityDissipation?: number | undefined`: Velocity retained by one reference simulation interval. ### SpatialGridHelper Kind: class; canonical: https://threejs-blocks.com/docs/api/SpatialGridHelper. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SpatialGridHelper } from "three-blocks/boids"; class SpatialGridHelper extends THREE.Object3D ``` **Purpose:** Helper for visualizing the spatial grid used by particle simulations. **Status:** Stable through the curated Boids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/boids. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/boids Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. - `atlasNumber: NumberTextureAtlasResult | null`: Number-label texture atlas owned by the helper, or `null` before initialization. - `constructor(simulation: SpatialGridHelperSimulation, showTexts?: boolean)`: Create and initialize a grid visualization for a simulation. - `dispose(): void`: Remove the helper geometry and labels from their scene and release their resources. - `init(): void`: Rebuild the grid-line visualization from the simulation's current domain. - `showTexts(): void`: Add instanced numeric cell labels using the helper's texture atlas. - `simulation: SpatialGridHelperSimulation`: Borrowed simulation whose grid is visualized. ### SphereImpostorNodeMaterial Kind: class; canonical: https://threejs-blocks.com/docs/api/SphereImpostorNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SphereImpostorNodeMaterial } from "three-blocks"; import { SphereImpostorNodeMaterial } from "three-blocks/sphere-impostors"; class SphereImpostorNodeMaterial extends THREE.MeshStandardNodeMaterial ``` **Purpose:** Standard-lit sphere impostors with SpriteNodeMaterial-style position semantics. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and setup. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks and three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. - `constructor(parameters?: SphereImpostorNodeMaterialParameters)`: Creates a standard-lit sphere-impostor material. The material owns its assembled shader nodes and follows the normal Three.js material lifecycle; call `dispose()` when finished. - `copy(source: SphereImpostorNodeMaterial): this`: Copy sphere-impostor inputs without retaining a position closure owned by source. - `readonly isSphereImpostorNodeMaterial: boolean`: Runtime type guard for sphere-impostor materials. - `positionNode: TSLVec3Node | null`: Particle center in object-local space, or null for the object origin. - `radiusNode: TSLFloatInput`: Particle radius in object-local units. - `setup(builder: NodeBuilder): void`: Keep the shadow position wired to this instance's assembled position node. Reapplying the same node makes rebuilds and clone/copy flows idempotent. - `setupPosition(): TSLVec3Node`: Replace positionLocal with the assembled camera-facing triangle. - `get sphereDepth(): boolean`: Whether to write projection-correct sphere depth. The default normal and normal MRT switch to the same ray/sphere surface while this is enabled. - `set sphereDepth(value: boolean)`: Whether to write projection-correct sphere depth. The default normal and normal MRT switch to the same ray/sphere surface while this is enabled. - `static get type(): string`: Stable material type name used by Three.js serialization and diagnostics. ### SphereImpostorNodeMaterialParameters Kind: interface; canonical: https://threejs-blocks.com/docs/api/SphereImpostorNodeMaterialParameters. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SphereImpostorNodeMaterialParameters } from "three-blocks/sphere-impostors"; interface SphereImpostorNodeMaterialParameters extends Omit ``` **Purpose:** Standard node-material parameters plus sphere-impostor placement controls. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SphereImpostorNodeMaterialParameters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. - `positionNode?: TSLVec3Node | null | undefined`: Particle center in object-local space, or null for the object origin. - `radiusNode?: TSLFloatInput | undefined`: Particle radius in object-local units. - `sphereDepth?: boolean | undefined`: Whether to write analytic sphere depth and use the matching surface normal. ### SphereImpostorNormalNodeMaterial Kind: class; canonical: https://threejs-blocks.com/docs/api/SphereImpostorNormalNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SphereImpostorNormalNodeMaterial } from "three-blocks/sphere-impostors"; class SphereImpostorNormalNodeMaterial extends THREE.MeshNormalNodeMaterial ``` **Purpose:** MeshNormalNodeMaterial adapter that restores NodeMaterial's regular opacity, alpha-test, and alpha-to-coverage setup before packing the view-space normal. Three r185's built-in MeshNormalNodeMaterial overrides setupDiffuseColor() without running that shared cutout path. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. - `constructor(parameters?: MeshNormalNodeMaterialParameters)`: Create a normal-debug material that preserves sphere-impostor cutouts. - `isSphereImpostorNormalNodeMaterial: boolean`: Runtime type guard that is always `true` for this material. - `setupDiffuseColor(builder?: NodeBuilder): void`: Overwrites the default implementation by computing the diffuse color based on the normal data. - `static get type(): string`: Stable material type name. ### SphereImpostorPositionConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/SphereImpostorPositionConfig. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { SphereImpostorPositionConfig } from "three-blocks/sphere-impostors"; interface SphereImpostorPositionConfig ``` **Purpose:** Placement and display-size controls accepted by sphereImpostorPosition. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for SphereImpostorPositionConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. - `maxPixelRadius?: TSLFloatInput | null | undefined`: Optional upper bound for the projected radius in display pixels. - `minPixelRadius?: TSLFloatInput | null | undefined`: Optional lower bound for the projected radius in display pixels. - `position?: TSLVec3Node | undefined`: Particle center in object-local space. - `radius?: TSLFloatInput | undefined`: Sphere radius in object-local units. - `screenSizeNode?: TSLVec2Node | null | undefined`: Display resolution used by pixel-radius clamps, or the active target when null. - `stretch?: TSLFloatInput | undefined`: Multiplier applied along the stretch direction. - `stretchDirection?: TSLVec2Node | null | undefined`: Optional normalized view-plane direction for elliptical stretching. ### SphereImpostorToonNodeMaterial Kind: class; canonical: https://threejs-blocks.com/docs/api/SphereImpostorToonNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SphereImpostorToonNodeMaterial } from "three-blocks/sphere-impostors"; class SphereImpostorToonNodeMaterial extends THREE.MeshToonNodeMaterial ``` **Purpose:** MeshToonNodeMaterial adapter whose lighting ramp consumes sphereImpostorNormal(). Wire the usual sphere-impostor position, opacity, normal, and shadow nodes to this material exactly as for the other preset materials. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. - `constructor(parameters?: MeshToonNodeMaterialParameters)`: Create a toon material whose lighting uses reconstructed sphere normals. - `isSphereImpostorToonNodeMaterial: boolean`: Runtime type guard that is always `true` for this material. - `setupLightingModel(): SphereImpostorToonLightingModel`: Setups the lighting model. - `static get type(): string`: Stable material type name. ### SplatClip Kind: class; canonical: https://threejs-blocks.com/docs/api/SplatClip. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SplatClip } from "three-blocks/gaussian-splats"; class SplatClip extends THREE.Object3D ``` **Purpose:** Plays a USV (`utsubo-splat-video`) clip: a pinned `GaussianSplats` whose dynamic tail is driven by a `SpacetimeSplatSource` resolve pass. The public playback surface mirrors SplatSequence (play/pause/`time`/loop/playbackSpeed/`update`/`prepareFrame`) so the existing bench + golden harness drive both interchangeably. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, load, update, pause, stop, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_4dgs_video. - `constructor(manifest: SplatVideoTracksManifest, payload: SplatClipPayload, options?: SplatClipOptions)`: Create a clip from a normalized manifest and decoded payload. - `get currentFrame(): number`: Current continuous frame position. - `dispose(): void`: Dispose the clip and its inner mesh. - `get duration(): number`: Clip duration in seconds. - `frameCount: number`: Number of authored frames. - `frameRate: number`: Authored playback frame rate. - `readonly isSplatClip: true`: Runtime type guard that is always `true` for splat clips. - `static load(source: SplatClipLoadSource, options?: SplatClipOptions): Promise`: Load a clip from a manifest URL (directory layout), a `.usv` bundle (URL or ArrayBuffer), or a pre-parsed manifest + fetcher pair. `ply-sequence` manifests route to a SplatSequence (the V0 dev encoding); `tracks` manifests return a `SplatClip`. - `loop: boolean`: Whether playback wraps at the end of the clip. - `manifest: SplatVideoTracksManifest`: Validated track manifest driving this clip. - `pause(): this`: Pause playback. - `play(): this`: Begin playback. - `playbackSpeed: number`: Playback-speed multiplier. - `playing: boolean`: Whether calls to update advance playback time. - `prepareFrame(frameIndex: number, options?: SplatSequencePrepareOptions): Promise`: Seek to a frame and wait until it completes a render — the deterministic capture path (mirrors SplatSequence#prepareFrame so the golden harness drives both). - `renderFrames(renderer: SplatSequenceRenderer, scene: THREE.Scene, camera: THREE.Camera, onFrame: (context: SplatClipRenderContext) => Promise | unknown, options?: SplatSequenceRenderRange): Promise`: Deterministically render a frame range, invoking a capture callback after every frame (mirrors SplatSequence#renderFrames). - `seekSeconds(seconds: number): this`: Seek to a playback time in seconds. - `setFrame(frameIndex: number): this`: Seek to a frame index (fractional frames allowed). - `get splats(): SplatClipMesh`: The inner GaussianSplats mesh (advanced integrations). - `get stats(): Record`: Renderer statistics of the inner mesh. - `stop(): this`: Stop playback and rewind to the first frame. - `get time(): number`: Current playback time in seconds. - `set time(seconds: number)`: Current playback time in seconds. - `readonly type: 'SplatClip'`: A Read-only _string_ to check `this` object type. - `update(deltaSeconds: number): void`: Advance playback (call from the application render loop). ### SplatMesh Kind: class; canonical: https://threejs-blocks.com/docs/api/SplatMesh. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SplatMesh } from "three-blocks/gaussian-splats"; class SplatMesh extends THREE.Object3D ``` **Purpose:** GPU-accelerated 3D Gaussian Splatting renderer for Three.js WebGPU. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, load, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_lit, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_lion, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_scene, https://threejs-blocks.com/examples/webgpu_gaussiansplat_splat, https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer, https://threejs-blocks.com/examples/webgpu_points_bvh_volume. - `addShadowLight(light: GaussianSplatShadowLight, options?: GaussianSplatShadowOptions): GaussianSplatShadowCaster | null`: Register this Gaussian scene as an alpha-clipped shadow caster for a directional, spot, or point light. The returned proxy is isolated on a shadow-camera-only layer. Set `light.shadow.autoUpdate = false` after the first render for static scenes. - `get alphaClip(): number`: Reject source splats below this base opacity before covariance projection. - `set alphaClip(value: number)`: Reject source splats below this base opacity before covariance projection. - `get alphaMode(): GaussianSplatsAlphaMode`: Set matching raster and compute-tile alpha semantics. - `set alphaMode(value: GaussianSplatsAlphaMode)`: Set matching raster and compute-tile alpha semantics. - `attachGUI(folder: GaussianGUIFolder): void`: Attach GUI controls. - `attributeMode: GaussianSplatsAttributeMode`: Resident attribute-storage representation. - `get autoUpdate(): boolean`: Get whether scene rendering automatically updates culling and sorting. Set whether scene rendering automatically updates culling and sorting. Disable this only when manually calling update(renderer, camera). - `set autoUpdate(value: boolean)`: Get whether scene rendering automatically updates culling and sorting. Set whether scene rendering automatically updates culling and sorting. Disable this only when manually calling update(renderer, camera). - `get blurAmount(): number`: Get the compensated screen-space filter variance. Set the compensated screen-space filter variance. Use 0.3 for the default Mip-style antialias filter or 0 to disable it. - `set blurAmount(value: number)`: Get the compensated screen-space filter variance. Set the compensated screen-space filter variance. Use 0.3 for the default Mip-style antialias filter or 0 to disable it. - `buffers: GaussianSplatsBuffers | null`: Resident GPU attribute buffers, or `null` before data is installed. - `compactAllowColorClamping: boolean`: Whether compact attribute conversion may clamp out-of-range colours. - `compaction: boolean`: Whether projected records are compacted before sorting and drawing. - `constructor(options?: GaussianSplatsOptions)`: Create a Gaussian Splatting renderer. - `count: number`: Number of active splats in the current data set. - `get debugIndirect(): boolean`: Enable/disable indirect draw debug logging. When enabled, logs instanceCount after each compute pass. - `set debugIndirect(value: boolean)`: Enable/disable indirect draw debug logging. When enabled, logs instanceCount after each compute pass. - `dispose(): void`: Dispose of GPU resources. - `drawStructNode: TSLStorageNode | null | undefined`: TSL storage node exposing the indirect draw structure. - `get enableSH(): boolean`: Get whether spherical harmonics are enabled. Set whether spherical harmonics are enabled. Triggers compute shader rebuild when changed. - `set enableSH(value: boolean)`: Get whether spherical harmonics are enabled. Set whether spherical harmonics are enabled. Triggers compute shader rebuild when changed. - `get fragmentAlphaClip(): number`: Set the raster fragment cutoff used by both projection tightening and material alpha testing. - `set fragmentAlphaClip(value: number)`: Set the raster fragment cutoff used by both projection tightening and material alpha testing. - `frustumCullingEnabled: boolean`: Whether compute projection rejects splats outside the camera frustum. - `getRenderRecommendation(renderer: THREE.Renderer, camera: THREE.Camera): GaussianSplatsRenderRecommendation`: Return a non-invasive render-scale recommendation for application-managed targets. The renderer is never resized by this method. - `indirect: THREE.IndirectStorageBufferAttribute | null | undefined`: Indirect draw arguments owned by the renderer. - `invalidate(): this`: Force the projection and depth-sort compute passes to re-run on the next update, even when the camera has not moved. Use this after mutating source data in place — for example when an animated source (blend/morph, spacetime) changes an attribute uniform without moving the camera, so the temporal-stability short-circuit would otherwise skip re-projection and re-sorting. - `invalidateShadows(): void`: Request fresh shadow maps for all registered Gaussian shadow lights. - `readonly isGaussianSplats: true`: Runtime type guard that is always `true` for Gaussian splat renderers. - `static load(url: string, options?: SplatMeshOptions): Promise`: Load a splat mesh with automatic scene updates and an optional quality preset. - `material: THREE.Material | GaussianSplatsMaterial | null`: Material currently used by the renderable splat mesh. - `get maxDataSHDegree(): number`: Get the maximum SH degree available from loaded data. - `maxSplats: number`: Allocated upper bound for resident splats. - `get maxStdDev(): number`: Get the maximum Gaussian extent in standard deviations. Set the maximum Gaussian extent in standard deviations. Reduce from Math.sqrt(8) toward Math.sqrt(5) to trade fringe overdraw for speed. - `set maxStdDev(value: number)`: Get the maximum Gaussian extent in standard deviations. Set the maximum Gaussian extent in standard deviations. Reduce from Math.sqrt(8) toward Math.sqrt(5) to trade fringe overdraw for speed. - `get minContribution(): number`: Reject projected splats below this alpha-area contribution estimate. Zero disables rejection. - `set minContribution(value: number)`: Reject projected splats below this alpha-area contribution estimate. Zero disables rejection. - `get opacityAwareRadius(): boolean`: Tighten projected raster footprints from opacity and the fragment cutoff. - `set opacityAwareRadius(value: boolean)`: Tighten projected raster footprints from opacity and the fragment cutoff. - `static parse(buffer: GaussianSplatsParseSource, url: string, options?: SplatMeshOptions): Promise`: Parse a splat mesh buffer with automatic scene updates and an optional quality preset. - `get preBlurAmount(): number`: Get the uncompensated pre-blur variance. Set the uncompensated pre-blur variance. Use this only for scenes trained without antialiasing. - `set preBlurAmount(value: number)`: Get the uncompensated pre-blur variance. Set the uncompensated pre-blur variance. Use this only for scenes trained without antialiasing. - `get radiusClip(): number`: Get the compute-level projected radius clipping threshold. Skip splats at or below a projected pixel radius before sorting. Keep this at 0 for maximum fidelity; raise it for large-scene performance tuning. - `set radiusClip(value: number)`: Get the compute-level projected radius clipping threshold. Skip splats at or below a projected pixel radius before sorting. Keep this at 0 for maximum fidelity; raise it for large-scene performance tuning. - `readIndirectArgs(): Promise`: Read back indirect draw arguments from GPU (debug/stats). - `readStats(): Promise`: Read current GPU-visible renderer statistics asynchronously. Intended for diagnostics and occasional performance checks, not per-frame application logic. - `readback(renderer: THREE.Renderer): Promise`: Read back sorted data from GPU for debugging. - `rebuildMaterialHooks(): void`: Rebuild projection and renderer nodes after changing custom material hooks. - `recommendedRenderScale: number`: Recommended application-managed render-scale multiplier. - `refreshShadowLights(): void`: Rebuild Gaussian shadow materials after changing custom position, scale, or color hooks. - `removeShadowLight(light: GaussianSplatShadowLight): void`: Remove this Gaussian scene from one light's shadow pass. - `get renderVersion(): number`: Completed non-shadow render count. - `rendererMode: GaussianSplatsRendererMode`: Active raster or compute-tile rendering path. - `setComputeTileLighting(lighting: SplatComputeTileLightingOptions): void`: Configure the compute-tile deferred lighting pass. Use mode:'scene' to shade the reconstructed surface with native Three.js scene lights, Scene.environment, AO, and received shadows. The default mode:'custom' preserves bounded Gaussian relighting. Pass a shadow-casting DirectionalLight as directional.light to project its shadows onto reconstructed splat surfaces. A shared directional.shadowNode avoids rendering the same shadow map again for standard mesh materials. - `setData(data: GaussianSplatsData): void`: Set splat data from parsed arrays. - `setOpaqueDepthTexture(texture: THREE.Texture | null): void`: Provide an opaque scene depth texture for compute-tile occlusion tests. The texture must match the active renderer dimensions. - `setShadowLightOptions(light: GaussianSplatShadowLight, options?: GaussianSplatShadowOptions): GaussianSplatShadowCaster | null`: Update options for an existing Gaussian shadow-light registration. - `setSourceBounds(min: ArrayLike, max: ArrayLike): this`: Override the source-space scene bounds used for scene-range sort-key normalization (I3). Streaming scenes set this from their manifest, since resident data is a moving subset of the full scene. - `get shDegree(): number`: Get the current spherical harmonics degree. Set the spherical harmonics degree (0-3). Clamped to the maximum degree available from loaded data. Triggers compute shader rebuild when changed. - `set shDegree(value: number)`: Get the current spherical harmonics degree. Set the spherical harmonics degree (0-3). Clamped to the maximum degree available from loaded data. Triggers compute shader rebuild when changed. - `sortAlgorithm: GaussianSplatsSortAlgorithm`: GPU sorting algorithm used for visible splats. - `sortCount: number`: Number of splats submitted to the latest sort. - `sortEnabled: boolean`: Whether visible splats are depth-sorted before drawing. - `sortMode: GaussianSplatsSortMode`: Active sorting policy. - `sortPrecision: GaussianSplatsSortPrecision`: Depth-key precision used by the sorter. - `sortRadixBits: 1 | 2 | 4 | 'auto'`: Radix bits processed by each sort pass. - `get splatCapacity(): number`: Resident-buffer capacity pin (high-water mark) for dynamic reuse. Raising this lets subsequent setData() calls with fewer splats reuse the resident buffers and compute pipeline instead of reallocating — and recompiling the projection/sort shaders — every frame. setData never shrinks below the live allocation, so this is effectively grow-only. 0 (default) leaves the static path byte-identical. Dynamic players (SplatSequence) raise this to the clip's largest frame. - `set splatCapacity(value: number)`: Resident-buffer capacity pin (high-water mark) for dynamic reuse. Raising this lets subsequent setData() calls with fewer splats reuse the resident buffers and compute pipeline instead of reallocating — and recompiling the projection/sort shaders — every frame. setData never shrinks below the live allocation, so this is effectively grow-only. 0 (default) leaves the static path byte-identical. Dynamic players (SplatSequence) raise this to the clip's largest frame. - `staticGroup: THREE.Group | null | undefined`: Group containing the current static render mesh. - `get stats(): GaussianSplatsStats`: Get CPU-visible renderer statistics without forcing GPU synchronization. Use readStats() when current GPU counts are required. - `temporalStability: boolean`: Whether unchanged camera state may reuse the previous projection and sort. - `uniforms: GaussianSplatsUniforms`: Mutable uniforms shared by the projection and draw graphs. - `update(renderer: THREE.Renderer, camera: THREE.Camera, viewContext?: SplatRenderViewContext): void`: Update splat rendering for current camera. Normally called automatically before the containing scene renders. - `get visibleCount(): number`: Get current visible splat count. Note: This reads from CPU-side array which may not reflect GPU value. Use readIndirectArgs() for accurate GPU readback. - `waitForRender(options?: GaussianSplatsWaitOptions): Promise`: Wait until this splat mesh completes a render after the requested render version. - `writeChunkBoundsRange(chunkOffset: number, bounds: ArrayLike): this`: Update hierarchical-culling chunk bounds for a chunk range (streaming residency). Each chunk covers 256 splats; bounds are 6 floats (min xyz, max xyz) per chunk in source space. - `writeSplatRange(offset: number, data: GaussianSplatsRangeData | null, srcIndex?: number, count?: number): this`: Partial splat write for streaming residency (expanded attribute mode only): packs `count` splats into GPU slots [offset, offset+count) with ranged buffer uploads, or zero-fills the range (alpha 0 — projection-culled) when `data` is null. ### SplatSequence Kind: class; canonical: https://threejs-blocks.com/docs/api/SplatSequence. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { SplatSequence } from "three-blocks/gaussian-splats"; class SplatSequence extends THREE.Object3D ``` **Purpose:** Plays numbered Gaussian splat files as a frame sequence. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, load, update, pause, stop, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. - `activeSplats: SplatSequenceMesh | null`: Renderable splat mesh for the active frame, or `null` before loading. - `static analyze(sources: readonly SplatSequenceSource[]): SplatSequenceAnalysis`: Inspect numbered PLY sources for sequence compatibility. - `cacheFrames: boolean`: Whether decoded owned frames are retained for reuse. - `constructor(sources?: SplatSequenceSource[], options?: SplatSequenceOptions)`: Create a splat sequence controller. - `currentFrame: number`: Zero-based active frame index, or `-1` before a frame is active. - `dispose(): void`: Dispose the sequence and its active sequence-owned frame. - `disposeFrames: boolean`: Whether sequence-owned frame meshes are disposed after replacement. - `get duration(): number`: Sequence duration in seconds. - `get frameCount(): number`: Number of frame sources in the sequence. - `frameRate: number`: Playback frames per second. - `frames: SplatSequenceSource[]`: Ordered frame sources currently assigned to the sequence. - `static fromFiles(files: SplatSequenceSource[], options?: SplatSequenceOptions): Promise`: Strictly validate and load a local numbered PLY sequence. - `static groupSequences(sources: readonly SplatSequenceSource[]): SplatSequenceAnalysis[]`: Group mixed files into numbered PLY sequences by filename prefix. - `static isSequence(sources: readonly SplatSequenceSource[]): boolean`: Return whether sources form one valid numbered splat sequence. - `readonly isSplatSequence: true`: Runtime type guard that is always `true` for splat sequences. - `static load(sources: SplatSequenceSource[], options?: SplatSequenceOptions): Promise`: Load a sequence and its first frame. - `loadFrame: SplatSequenceFrameLoader | null`: Optional custom asynchronous frame loader. - `loop: boolean`: Whether playback wraps at the final frame. - `maxCachedFrames: number`: Maximum number of decoded owned frames retained by the cache. - `nextFrame(): Promise`: Activate the next frame, wrapping at the end. - `pause(): this`: Pause sequence playback. - `play(): this`: Begin sequence playback. - `playbackSpeed: number`: Playback-speed multiplier. - `playing: boolean`: Whether calls to update advance playback. - `prepareFrame(frameIndex: number, options?: SplatSequencePrepareOptions): Promise`: Load a frame and wait until it completes a render. When a renderer is provided, this method renders the containing scene immediately; otherwise it waits for the application render loop. - `previousFrame(): Promise`: Activate the previous frame, wrapping at the beginning. - `renderFrames(renderer: SplatSequenceRenderer, scene: THREE.Scene, camera: THREE.Camera, onFrame: (context: SplatSequenceRenderContext) => Promise | unknown, options?: SplatSequenceRenderRange): Promise`: Deterministically render a frame range and invoke a capture callback after every frame. - `seekFrame(frameIndex: number): Promise`: Seek to a zero-based frame index. - `seekSeconds(seconds: number): Promise`: Seek to a playback time in seconds. - `setFrame(frameIndex: number): Promise`: Request a frame. Newer requests replace stale queued requests while a frame loads. - `setFrames(sources: SplatSequenceSource[]): this`: Replace the sequence sources and clear the active frame. - `sortFrames: boolean`: Whether numbered sources are sorted before playback. - `splatOptions: SplatSequenceSplatOptions`: Options forwarded when a frame creates its Gaussian mesh. - `stop(): this`: Stop playback and request the first frame. - `strict: boolean`: Whether inputs must form one complete numbered sequence. - `time: number`: Current playback time in seconds. - `update(deltaSeconds: number): void`: Advance playback and request the corresponding frame. ### StandardAssetAdapters Kind: type; canonical: https://threejs-blocks.com/docs/api/StandardAssetAdapters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StandardAssetAdapters } from "three-blocks/assets"; type StandardAssetAdapters = {readonly [TType in keyof StandardAssetDefinitionMap]: AssetAdapter;} ``` **Purpose:** Declares StandardAssetAdapters as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StandardAssetAdapters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StandardAssetDefinition Kind: type; canonical: https://threejs-blocks.com/docs/api/StandardAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StandardAssetDefinition } from "three-blocks/assets"; type StandardAssetDefinition = GltfAssetDefinition | GlbAssetDefinition | HdrAssetDefinition | ExrAssetDefinition | ImageAssetDefinition | TextureAssetDefinition | Ktx2AssetDefinition | JsonAssetDefinition | BinaryAssetDefinition | CubeTextureAssetDefinition | AudioAssetDefinition | FontAssetDefinition ``` **Purpose:** Declares StandardAssetDefinition as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StandardAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StandardAssetDefinitionMap Kind: interface; canonical: https://threejs-blocks.com/docs/api/StandardAssetDefinitionMap. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StandardAssetDefinitionMap } from "three-blocks/assets"; interface StandardAssetDefinitionMap ``` **Purpose:** The standard vocabulary; concrete renderer/decoder adapters remain explicit dependencies. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StandardAssetDefinitionMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly audio: AudioAssetDefinition` - `readonly binary: BinaryAssetDefinition` - `readonly cubeTexture: CubeTextureAssetDefinition` - `readonly exr: ExrAssetDefinition` - `readonly font: FontAssetDefinition` - `readonly glb: GlbAssetDefinition` - `readonly gltf: GltfAssetDefinition` - `readonly hdr: HdrAssetDefinition` - `readonly image: ImageAssetDefinition` - `readonly json: JsonAssetDefinition` - `readonly ktx2: Ktx2AssetDefinition` - `readonly texture: TextureAssetDefinition` ### StandardAssetResultMap Kind: type; canonical: https://threejs-blocks.com/docs/api/StandardAssetResultMap. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StandardAssetResultMap } from "three-blocks/assets"; type StandardAssetResultMap = {readonly [TType in keyof StandardAssetDefinitionMap]: unknown;} ``` **Purpose:** Declares StandardAssetResultMap as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StandardAssetResultMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StatsMainAdapter Kind: class; canonical: https://threejs-blocks.com/docs/api/StatsMainAdapter. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { StatsMainAdapter } from "three-blocks/stats"; class StatsMainAdapter ``` **Purpose:** DOM-side stats panel with local CPU timing and push-driven worker metrics. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(options?: StatsMainOptions)` - `dispose(): void` - `init(): Promise` - `get initialized(): boolean` - `get mode(): StatsPanelMode` - `receive(snapshot: StatsSnapshot): void` - `receiveTexture(frame: StatsTextureFrame): void` - `setMode(mode: StatsPanelMode): void` ### StatsMainOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsMainOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsMainOptions } from "three-blocks/stats"; interface StatsMainOptions ``` **Purpose:** Declares StatsMainOptions as a public interface. It is exported from three-blocks/stats. Its declared surface covers container, createPanel, enabled, keyboardTarget, and mode, plus 5 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsMainOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly container?: ContainerLike` - `readonly createPanel?: StatsMainPanelFactory` - `readonly enabled?: boolean` - `readonly keyboardTarget?: KeyboardTargetLike` - `readonly mode?: StatsPanelMode` - `readonly onTexturePanelState?: (name: string, state: StatsTexturePanelState) => void` - `readonly onTextureUpdate?: (name: string) => void` - `readonly texturePanels?: readonly string[]` - `readonly textureSources?: readonly StatsMainTextureSource[]`: Main-thread surfaces sampled locally without worker readback or image transfer. - `readonly toggleKey?: string` ### StatsMainPanelFactory Kind: type; canonical: https://threejs-blocks.com/docs/api/StatsMainPanelFactory. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsMainPanelFactory } from "three-blocks/stats"; type StatsMainPanelFactory = () => PromiseLike | StatsMainPanelLike ``` **Purpose:** Declares StatsMainPanelFactory as a public type. It is exported from three-blocks/stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsMainPanelFactory. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StatsMainPanelLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsMainPanelLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsMainPanelLike } from "three-blocks/stats"; interface StatsMainPanelLike ``` **Purpose:** Declares StatsMainPanelLike as a public interface. It is exported from three-blocks/stats. Its declared surface covers addTexturePanel, begin, dispose, dom, and setData, plus 3 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: update and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `addTexturePanel(name: string): unknown` - `begin(): void` - `dispose(): void` - `readonly dom: PanelDomLike` - `setData(data: StatsProfilerData & {readonly isWorker?: boolean;}): void` - `setTextureBitmap(name: string, bitmap: object, width?: number, height?: number): void` - `showPanel?(id: number): void` - `update(): void` ### StatsMainTextureSource Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsMainTextureSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsMainTextureSource } from "three-blocks/stats"; interface StatsMainTextureSource ``` **Purpose:** Declares StatsMainTextureSource as a public interface. It is exported from three-blocks/stats. Its declared surface covers height, name, sampleRate, source, and width. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsMainTextureSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly height: number` - `readonly name: string` - `readonly sampleRate?: number`: Maximum local texture-thumbnail refreshes per second. Defaults to 15. - `readonly source: object | (() => object | null | undefined)` - `readonly width: number` ### StatsPanelMode Kind: type; canonical: https://threejs-blocks.com/docs/api/StatsPanelMode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsPanelMode } from "three-blocks/stats"; type StatsPanelMode = 'compact' | 'expanded' | 'hidden' ``` **Purpose:** Declares StatsPanelMode as a public type. It is exported from three-blocks/stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsPanelMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StatsProfilerData Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsProfilerData. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsProfilerData } from "three-blocks/stats"; interface StatsProfilerData ``` **Purpose:** Declares StatsProfilerData as a public interface. It is exported from three-blocks/stats. Its declared surface covers cpu, fps, gpu, and gpuCompute. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsProfilerData. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cpu: number` - `readonly fps: number` - `readonly gpu: number` - `readonly gpuCompute: number` ### StatsProfilerFactory Kind: type; canonical: https://threejs-blocks.com/docs/api/StatsProfilerFactory. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsProfilerFactory } from "three-blocks/stats"; type StatsProfilerFactory = (options: StatsProfilerOptions) => PromiseLike | StatsProfilerLike ``` **Purpose:** Declares StatsProfilerFactory as a public type. It is exported from three-blocks/stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsProfilerFactory. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StatsProfilerLike Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsProfilerLike. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsProfilerLike } from "three-blocks/stats"; interface StatsProfilerLike ``` **Purpose:** Declares StatsProfilerLike as a public interface. It is exported from three-blocks/stats. Its declared surface covers begin, captureTexture, dispose, end, and getData, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: init, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `begin(): void` - `captureTexture?(source: unknown, sourceId?: string): PromiseLike` - `dispose(): void` - `end(): void` - `getData(): StatsProfilerData` - `init(renderer: unknown): PromiseLike | void` - `update(): void` ### StatsProfilerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsProfilerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsProfilerOptions } from "three-blocks/stats"; interface StatsProfilerOptions ``` **Purpose:** Declares StatsProfilerOptions as a public interface. It is exported from three-blocks/stats. Its declared surface covers graphsPerSecond, logsPerSecond, maxTimestampPairs, precision, and samplesGraph, plus 5 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsProfilerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly graphsPerSecond?: number` - `readonly logsPerSecond?: number` - `readonly maxTimestampPairs?: number` - `readonly precision?: number` - `readonly samplesGraph?: number` - `readonly samplesLog?: number` - `readonly trackCPT?: boolean` - `readonly trackFPS?: boolean` - `readonly trackGPU?: boolean` - `readonly trackHz?: boolean` ### StatsSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsSnapshot } from "three-blocks/stats"; interface StatsSnapshot ``` **Purpose:** Push-based stats-gl adapters for worker-owned rendering. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cpu: number` - `readonly fps: number` - `readonly gpu: number` - `readonly gpuCompute: number` - `readonly sequence: number` - `readonly timestamp: number` ### StatsTextureFrame Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsTextureFrame. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsTextureFrame } from "three-blocks/stats"; interface StatsTextureFrame ``` **Purpose:** Declares StatsTextureFrame as a public interface. It is exported from three-blocks/stats. Its declared surface covers bitmap, height, name, sequence, and timestamp, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsTextureFrame. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bitmap: TBitmap` - `readonly height: number` - `readonly name: string` - `readonly sequence: number` - `readonly timestamp: number` - `readonly width: number` ### StatsTexturePanelState Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsTexturePanelState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsTexturePanelState } from "three-blocks/stats"; interface StatsTexturePanelState ``` **Purpose:** Declares StatsTexturePanelState as a public interface. It is exported from three-blocks/stats. Its declared surface covers enabled and visible. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsTexturePanelState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly enabled: boolean` - `readonly visible: boolean` ### StatsTextureRenderer Kind: type; canonical: https://threejs-blocks.com/docs/api/StatsTextureRenderer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsTextureRenderer } from "three-blocks/app"; type StatsTextureRenderer = (target: RenderTarget) => PromiseLike ``` **Purpose:** Declares StatsTextureRenderer as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsTextureRenderer. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StatsWorkerAdapter Kind: class; canonical: https://threejs-blocks.com/docs/api/StatsWorkerAdapter. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { StatsWorkerAdapter } from "three-blocks/stats"; class StatsWorkerAdapter ``` **Purpose:** Long-lived worker profiler that survives scene/component HMR. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, init, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `beginFrame(): void` - `captureTexture(name: string, source: unknown, width: number, height: number): Promise` - `constructor(options: StatsWorkerOptions)` - `dispose(): void` - `get enabled(): boolean` - `endFrame(): StatsSnapshot | undefined`: Complete profiling and drain renderer timestamps every frame, but throttle snapshots. - `init(renderer: unknown): Promise` - `get initialized(): boolean` - `setTexturePanelState(name: string, state: StatsTexturePanelState): void` ### StatsWorkerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/StatsWorkerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StatsWorkerOptions } from "three-blocks/stats"; interface StatsWorkerOptions ``` **Purpose:** Declares StatsWorkerOptions as a public interface. It is exported from three-blocks/stats. Its declared surface covers createProfiler, enabled, now, profiler, and publish, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StatsWorkerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly createProfiler?: StatsProfilerFactory` - `readonly enabled?: boolean`: Disabled adapters do not import stats-gl or add update-loop work. - `readonly now?: () => number`: Monotonic milliseconds. - `readonly profiler?: StatsProfilerOptions` - `readonly publish: (snapshot: StatsSnapshot) => void` - `readonly publishTexture?: (frame: StatsTextureFrame, transfer: readonly object[]) => void` - `readonly sampleRate?: number`: Maximum pushed metric snapshots per second. Defaults to 15. ### StatusOverlay Kind: class; canonical: https://threejs-blocks.com/docs/api/StatusOverlay. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { StatusOverlay } from "three-blocks/app"; class StatusOverlay ``` **Purpose:** Owns the generated app's compact lifecycle/error element. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(element: string | HTMLElement)` - `readonly element: HTMLElement` - `ready(diagnostics: RuntimeDiagnostics, text: boolean): void` - `reportError(error: unknown): void` - `reset(detail?: string): void` - `setStatus(status: RuntimeStatus): void` ### StructuredCloneBuiltin Kind: type; canonical: https://threejs-blocks.com/docs/api/StructuredCloneBuiltin. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StructuredCloneBuiltin } from "three-blocks/worker"; type StructuredCloneBuiltin = ArrayBuffer | ArrayBufferView | Date | RegExp | SharedArrayBuffer ``` **Purpose:** Declares StructuredCloneBuiltin as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StructuredCloneBuiltin. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StructuredClonePrimitive Kind: type; canonical: https://threejs-blocks.com/docs/api/StructuredClonePrimitive. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StructuredClonePrimitive } from "three-blocks/worker"; type StructuredClonePrimitive = null | undefined | void | boolean | number | bigint | string ``` **Purpose:** Declares StructuredClonePrimitive as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StructuredClonePrimitive. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StructuredCloneable Kind: type; canonical: https://threejs-blocks.com/docs/api/StructuredCloneable. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StructuredCloneable } from "three-blocks/worker"; type StructuredCloneable = StructuredClonePrimitive | StructuredCloneBuiltin | readonly StructuredCloneable[] | {readonly [key: string]: StructuredCloneable;} ``` **Purpose:** Values accepted by the browser structured-clone algorithm or a transfer list. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StructuredCloneable. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### StructuredCloneableShape Kind: type; canonical: https://threejs-blocks.com/docs/api/StructuredCloneableShape. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { StructuredCloneableShape } from "three-blocks/worker"; type StructuredCloneableShape = TValue extends TransferableValue ? TValue: TValue extends (...args: never[]) => unknown ? never: TValue extends StructuredClonePrimitive | StructuredCloneBuiltin ? TValue: TValue extends ReadonlyMap ? ReadonlyMap, StructuredCloneableShape>: TValue extends ReadonlySet ? ReadonlySet>: TValue extends readonly (infer TEntry)[] ? readonly StructuredCloneableShape[]: TValue extends object ? {readonly [TKey in keyof TValue]: StructuredCloneableShape;}: never ``` **Purpose:** Recursively preserves a contract shape while replacing non-cloneable members with never. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for StructuredCloneableShape. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TEXT_SCHEMA_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/TEXT_SCHEMA_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { TEXT_SCHEMA_VERSION } from "three-blocks/text"; const TEXT_SCHEMA_VERSION: 1 ``` **Purpose:** Environment-neutral configuration and bridge contracts for DOM-synchronized MSDF text. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TEXT_SCHEMA_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_CLIENT_CONFIG_ID Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_CLIENT_CONFIG_ID. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_CLIENT_CONFIG_ID } from "three-blocks/vite"; const THREE_BLOCKS_CLIENT_CONFIG_ID: "three-blocks/vite/config" ``` **Purpose:** Declares THREE_BLOCKS_CLIENT_CONFIG_ID as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_CLIENT_CONFIG_ID. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_SUPPORTED_THREE_RANGE Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_SUPPORTED_THREE_RANGE. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_SUPPORTED_THREE_RANGE } from "three-blocks/vite"; const THREE_BLOCKS_SUPPORTED_THREE_RANGE: ">=0.185.0 <0.186.0" ``` **Purpose:** Declares THREE_BLOCKS_SUPPORTED_THREE_RANGE as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_SUPPORTED_THREE_RANGE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION } from "three-blocks/vite"; const THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION: "r186dev-provider-v19" ``` **Purpose:** Declares THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_THREE_186DEV_HOOK_TRANSFORM_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION } from "three-blocks/vite"; const THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION: "r185-capture-v5" ``` **Purpose:** Declares THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_THREE_CAPTURE_TRANSFORM_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION } from "three-blocks/vite"; const THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION: "r185-codec-urls-v2" ``` **Purpose:** Declares THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_THREE_CODEC_TRANSFORM_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION } from "three-blocks/vite"; const THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION: "r185-provider-v21" ``` **Purpose:** Declares THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION as a public value. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_THREE_HOOK_TRANSFORM_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_BLOCKS_VITE_SCHEMA_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_BLOCKS_VITE_SCHEMA_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_BLOCKS_VITE_SCHEMA_VERSION } from "three-blocks/vite"; import { THREE_BLOCKS_VITE_SCHEMA_VERSION } from "three-blocks/vite/config"; const THREE_BLOCKS_VITE_SCHEMA_VERSION: 2 ``` **Purpose:** Environment-neutral contracts injected by `three-blocks/vite`. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_BLOCKS_VITE_SCHEMA_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_R185_MATERIAL_SLOTS Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_R185_MATERIAL_SLOTS. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_R185_MATERIAL_SLOTS } from "three-blocks/shaders"; const THREE_R185_MATERIAL_SLOTS: readonly ["fragmentNode", "vertexNode", "colorNode", "positionNode", "normalNode", "opacityNode", "alphaTestNode", "backdropNode", "backdropAlphaNode", "emissiveNode", "metalnessNode", "roughnessNode", "clearcoatNode", "clearcoatRoughnessNode", "transmissionNode", "thicknessNode", "iorNode", "outputNode", "mrtNode", "depthNode", "castShadowNode", "receivedShadowNode", "maskNode", "envNode"] ``` **Purpose:** Declares THREE_R185_MATERIAL_SLOTS as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_R185_MATERIAL_SLOTS. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_R186DEV_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_R186DEV_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_R186DEV_VERSION } from "three-blocks/shaders"; const THREE_R186DEV_VERSION: "0.186.0-dev" ``` **Purpose:** Declares THREE_R186DEV_VERSION as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_R186DEV_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_WEBGL_R185_COMPATIBILITY Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_WEBGL_R185_COMPATIBILITY. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_WEBGL_R185_COMPATIBILITY } from "three-blocks/shaders"; const THREE_WEBGL_R185_COMPATIBILITY: "three-webgl-r185-v1" ``` **Purpose:** Declares THREE_WEBGL_R185_COMPATIBILITY as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_WEBGL_R185_COMPATIBILITY. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_WEBGPU_R185_COMPATIBILITY Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_WEBGPU_R185_COMPATIBILITY. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_WEBGPU_R185_COMPATIBILITY } from "three-blocks/shaders"; const THREE_WEBGPU_R185_COMPATIBILITY: "three-webgpu-r185-v1" ``` **Purpose:** Declares THREE_WEBGPU_R185_COMPATIBILITY as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_WEBGPU_R185_COMPATIBILITY. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### THREE_WEBGPU_R186DEV_COMPATIBILITY Kind: variable; canonical: https://threejs-blocks.com/docs/api/THREE_WEBGPU_R186DEV_COMPATIBILITY. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { THREE_WEBGPU_R186DEV_COMPATIBILITY } from "three-blocks/shaders"; const THREE_WEBGPU_R186DEV_COMPATIBILITY: "three-webgpu-r186dev-v1" ``` **Purpose:** Declares THREE_WEBGPU_R186DEV_COMPATIBILITY as a public value. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for THREE_WEBGPU_R186DEV_COMPATIBILITY. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### Text Kind: class; canonical: https://threejs-blocks.com/docs/api/Text. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { Text } from "three-blocks/experimental/runtime-sdf-text"; class Text extends Mesh implements TextNodeSource, TextColorNodeSource ``` **Purpose:** High-quality SDF-based text rendering with GPU-accelerated glyph generation. **Status:** Experimental through the curated Runtime SDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/runtime-sdf-text. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/runtime-sdf-text Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. - `anchorX: TextSyncableProperties['anchorX']` - `anchorY: TextSyncableProperties['anchorY']` - `get billboarding(): boolean`: Enable yaw-only billboarding so text always faces the camera. When enabled, text rotates around the Y-axis to face the camera while remaining upright. - `set billboarding(value: boolean)`: Enable yaw-only billboarding so text always faces the camera. When enabled, text rotates around the Y-axis to face the camera while remaining upright. - `clipRect: TextClipRect | null` - `clone(): this`: Returns a clone of `this` object and optionally all descendants. - `color: ColorRepresentation` - `colorRanges: TextSyncableProperties['colorRanges']` - `constructor()` - `copy(source: this): this`: Copies the given object into this object. - `debugSDF: boolean` - `depthOffset: number` - `direction: TextSyncableProperties['direction']` - `dispose(): void`: Dispose of geometry resources. - `fillOpacity: number | null` - `font: TextSyncableProperties['font']` - `fontSize: TextSyncableProperties['fontSize']` - `fontStyle: TextSyncableProperties['fontStyle']` - `fontWeight: TextSyncableProperties['fontWeight']` - `get glyphGeometryDetail(): number`: Geometry tessellation detail level (1-3). - `set glyphGeometryDetail(detail: number)`: Geometry tessellation detail level (1-3). - `gpuAccelerateSDF: boolean` - `lang: TextSyncableProperties['lang']` - `letterSpacing: TextSyncableProperties['letterSpacing']` - `lineHeight: TextSyncableProperties['lineHeight']` - `localPositionToTextCoords(position: Vector2 | Vector3, target?: Vector2): Vector2` - `maxWidth: TextSyncableProperties['maxWidth']` - `onAfterRender(_renderer: Renderer | WebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, material: Material): void`: Post-render hook: restores material side setting. - `onBeforeRender(renderer: Renderer | WebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, material: Material): void`: Pre-render hook: ensures text is synced and material configured. - `orientation: string` - `outlineBlur: TextLength` - `outlineColor: ColorRepresentation` - `outlineOffsetX: TextLength` - `outlineOffsetY: TextLength` - `outlineOpacity: number | null` - `outlineWidth: TextLength` - `overflowWrap: TextSyncableProperties['overflowWrap']` - `patchWebGPU(indices: ArrayLike): [indices: Float32Array, letterIndices: Float32Array]` - `raycast(raycaster: Raycaster, intersects: Intersection[]): void`: Abstract (empty) method to get intersections between a casted ray and this object - `get screenSpace(): boolean`: Enable screen-space rendering mode where text is positioned in NDC coordinates. When enabled, text position is mapped from layout coordinates to screen pixels using the viewport dimensions, useful for DOM-synchronized text overlays. - `set screenSpace(value: boolean)`: Enable screen-space rendering mode where text is positioned in NDC coordinates. When enabled, text position is mapped from layout coordinates to screen pixels using the viewport dimensions, useful for DOM-synchronized text overlays. - `sdfGlyphSize: TextSyncableProperties['sdfGlyphSize']` - `sdfMap: TSLTextureNode | undefined` - `sync(callback?: TextSyncCallback | null | undefined, renderer?: Renderer): void`: Trigger asynchronous glyph layout and SDF atlas generation. Called automatically before render if text properties changed. - `text: TextSyncableProperties['text']` - `textAlign: TextSyncableProperties['textAlign']` - `textIndent: TextSyncableProperties['textIndent']` - `get textRenderInfo(): TextRenderInfo | null`: Get the computed text layout and SDF atlas information. - `unicodeFontsURL: string | null` - `uniforms: TextNodeUniforms` - `whiteSpace: TextSyncableProperties['whiteSpace']` - `worldPositionToTextCoords(position: Vector3, target?: Vector2): Vector2` ### TextBatch Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextBatch. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextBatch } from "three-blocks/text/worker"; interface TextBatch ``` **Purpose:** Declares TextBatch as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers addText, dispose, material, name, and removeText, plus 9 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `addText(options: {readonly lines: readonly unknown[]; readonly matrix: Matrix4; readonly fontSize: number; readonly letterSpacing: number; readonly color: number; readonly opacity: number;}): number` - `dispose(): void` - `readonly material: object` - `name: string` - `removeText(id: number): unknown` - `renderOrder: number` - `setColorAt(id: number, color: number): unknown` - `setLayoutAt(id: number, options: {readonly fontSize: number; readonly letterSpacing: number;}): unknown` - `setLinesAt(id: number, lines: readonly {readonly text: string; readonly x: number; readonly y: number; readonly width: number;}[]): unknown` - `setMatrixAt(id: number, matrix: Matrix4): unknown` - `setOpacityAt(id: number, opacity: number): unknown` - `setScreenOffset(x: number, y: number): unknown` - `setViewport(width: number, height: number): unknown` - `weightBias: number` ### TextBridgeEvents Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextBridgeEvents. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextBridgeEvents } from "three-blocks/text"; interface TextBridgeEvents ``` **Purpose:** Declares TextBridgeEvents as a public interface. It is exported from three-blocks/text. Its declared surface covers textBatch. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextBridgeEvents. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly textBatch: TextSyncBatch` ### TextBridgeState Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextBridgeState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextBridgeState } from "three-blocks/text"; interface TextBridgeState ``` **Purpose:** Latest complete snapshot is replayed after worker restart; incremental batches stay ordered events. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextBridgeState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly textSnapshot: TextSyncBatch` ### TextCanvasRect Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextCanvasRect. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextCanvasRect } from "three-blocks/text"; interface TextCanvasRect ``` **Purpose:** Declares TextCanvasRect as a public interface. It is exported from three-blocks/text. Its declared surface covers height and width. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextCanvasRect. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly height: number` - `readonly width: number` ### TextComputedStyle Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextComputedStyle. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextComputedStyle } from "three-blocks/text"; interface TextComputedStyle ``` **Purpose:** Declares TextComputedStyle as a public interface. It is exported from three-blocks/text. Its declared surface covers color, fontFamily, fontKey, fontSize, and fontWeight, plus 5 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextComputedStyle. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly color: number` - `readonly fontFamily: string` - `readonly fontKey: string | null` - `readonly fontSize: number` - `readonly fontWeight: number` - `readonly language: string` - `readonly letterSpacing: number` - `readonly opacity: number` - `readonly textAlign: string` - `readonly textTransform: string` ### TextConfiguration Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextConfiguration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextConfiguration } from "three-blocks/text"; interface TextConfiguration> = Readonly>> ``` **Purpose:** Declares TextConfiguration as a public interface. It is exported from three-blocks/text. Its declared surface covers content, fonts, generation, and schemaVersion. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextConfiguration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly content: readonly string[]`: Semantic HTML and typed content modules inspected by text tooling. - `readonly fonts: TFonts` - `readonly generation?: TextGenerationOptions` - `readonly schemaVersion?: typeof TEXT_SCHEMA_VERSION` ### TextContentValue Kind: type; canonical: https://threejs-blocks.com/docs/api/TextContentValue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextContentValue } from "three-blocks/text"; type TextContentValue = string | readonly TextContentValue[] | {readonly [key: string]: TextContentValue;} ``` **Purpose:** Declares TextContentValue as a public type. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextContentValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextCreateUpdate Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextCreateUpdate. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextCreateUpdate } from "three-blocks/text"; interface TextCreateUpdate ``` **Purpose:** Declares TextCreateUpdate as a public interface. It is exported from three-blocks/text. Its declared surface covers id, lines, rect, styles, and type, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextCreateUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly id: string` - `readonly lines: readonly TextLineBox[]` - `readonly rect: TextElementRect` - `readonly styles: TextComputedStyle` - `readonly type: 'create' | 'update'` - `readonly visible: boolean` - `readonly zIndex: number` ### TextElementRect Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextElementRect. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextElementRect } from "three-blocks/text"; interface TextElementRect extends TextCanvasRect ``` **Purpose:** Declares TextElementRect as a public interface. It is exported from three-blocks/text. Its declared surface covers x and y. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextElementRect. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly x: number` - `readonly y: number` ### TextElementUpdate Kind: type; canonical: https://threejs-blocks.com/docs/api/TextElementUpdate. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextElementUpdate } from "three-blocks/text"; type TextElementUpdate = TextCreateUpdate | TextRectUpdate | TextVisibilityUpdate | TextRemoveUpdate ``` **Purpose:** Declares TextElementUpdate as a public type. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextElementUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextErrorState Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextErrorState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextErrorState } from "three-blocks/text"; interface TextErrorState ``` **Purpose:** Declares TextErrorState as a public interface. It is exported from three-blocks/text. Its declared surface covers message, missingGlyphs, and ready. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextErrorState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly message: string` - `readonly missingGlyphs: readonly number[]` - `readonly ready: false` ### TextFallbackSignal Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextFallbackSignal. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFallbackSignal } from "three-blocks/text"; interface TextFallbackSignal ``` **Purpose:** Worker-to-main signal controlling accessible DOM fallback for affected elements. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFallbackSignal. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly diagnostic?: MissingGlyphDiagnostic` - `readonly elementIds: readonly string[]`: Empty means every synchronized element. - `readonly status: TextFallbackStatus` ### TextFallbackStatus Kind: type; canonical: https://threejs-blocks.com/docs/api/TextFallbackStatus. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFallbackStatus } from "three-blocks/text"; type TextFallbackStatus = 'loading' | 'ready' | 'fallback' | 'error' ``` **Purpose:** Declares TextFallbackStatus as a public type. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFallbackStatus. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextFontLoadContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextFontLoadContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontLoadContext } from "three-blocks/text/worker"; interface TextFontLoadContext ``` **Purpose:** Declares TextFontLoadContext as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers key, revision, route, and weight. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontLoadContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly key: string` - `readonly revision: number` - `readonly route: TextFontRoute`: Route with `atlas`/`metrics` already resolved to the requested weight variant. - `readonly weight: number`: Baked weight of the atlas variant being loaded. ### TextFontLoader Kind: type; canonical: https://threejs-blocks.com/docs/api/TextFontLoader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontLoader } from "three-blocks/text/worker"; type TextFontLoader = (context: TextFontLoadContext) => PromiseLike ``` **Purpose:** Declares TextFontLoader as a public type. It is exported from three-blocks/text/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontLoader. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextFontMetrics Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextFontMetrics. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontMetrics } from "three-blocks/text/worker"; interface TextFontMetrics ``` **Purpose:** Declares TextFontMetrics as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers atlasHeight, atlasWidth, descender, distanceRange, and has, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontMetrics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlasHeight?: number` - `readonly atlasWidth?: number` - `readonly descender: number` - `readonly distanceRange?: number` - `has(codePoint: number): boolean` - `readonly size?: number`: Atlas generation size (px per em); used with distanceRange to scale synthetic weight. ### TextFontRoute Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextFontRoute. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontRoute } from "three-blocks/text"; interface TextFontRoute ``` **Purpose:** Declares TextFontRoute as a public interface. It is exported from three-blocks/text. Its declared surface covers atlas, browser, default, families, and languages, plus 3 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontRoute. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlas: string`: Generated RGBA8 KTX2 MSDF atlas. Represents weight 400 unless `weights` overrides it. - `readonly browser: string`: Browser font used by DOM layout. - `readonly default?: boolean` - `readonly families: readonly string[]` - `readonly languages?: readonly string[]` - `readonly metrics: string`: Generated glyph, metric, and kerning metadata. - `readonly source: TextFontSource`: Authoring font input. It is hashed by tooling and is not deployed automatically. - `readonly weights?: Readonly>`: Atlas instances baked at other weights (`msdf-atlas --wght`); keys are CSS weight numbers. ### TextFontSource Kind: type; canonical: https://threejs-blocks.com/docs/api/TextFontSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontSource } from "three-blocks/text"; type TextFontSource = BuiltinTextFontSource | ProjectTextFontSource | PackageTextFontSource ``` **Purpose:** Declares TextFontSource as a public type. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextFontWeightVariant Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextFontWeightVariant. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextFontWeightVariant } from "three-blocks/text"; interface TextFontWeightVariant ``` **Purpose:** Declares TextFontWeightVariant as a public interface. It is exported from three-blocks/text. Its declared surface covers atlas and metrics. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextFontWeightVariant. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlas: string`: Generated RGBA8 KTX2 MSDF atlas instanced at this weight. - `readonly metrics: string`: Generated glyph, metric, and kerning metadata instanced at this weight. ### TextGenerationOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextGenerationOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextGenerationOptions } from "three-blocks/text"; interface TextGenerationOptions ``` **Purpose:** Declares TextGenerationOptions as a public interface. It is exported from three-blocks/text. Its declared surface covers additionalCharacters, distanceRange, maxTextureSize, padding, and presets, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextGenerationOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly additionalCharacters?: string` - `readonly distanceRange?: number` - `readonly maxTextureSize?: number` - `readonly padding?: number` - `readonly presets?: readonly TextUnicodePreset[]` - `readonly ranges?: readonly TextUnicodeRange[]` - `readonly size?: number` ### TextLineBox Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextLineBox. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextLineBox } from "three-blocks/text"; interface TextLineBox ``` **Purpose:** Declares TextLineBox as a public interface. It is exported from three-blocks/text. Its declared surface covers bottom, text, top, width, and x. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextLineBox. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bottom: number` - `readonly text: string` - `readonly top: number` - `readonly width: number` - `readonly x: number` ### TextReadyState Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextReadyState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextReadyState } from "three-blocks/text"; interface TextReadyState ``` **Purpose:** Declares TextReadyState as a public interface. It is exported from three-blocks/text. Its declared surface covers batches, fonts, missingGlyphs, and ready. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextReadyState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly batches: number` - `readonly fonts: readonly string[]` - `readonly missingGlyphs: readonly number[]` - `readonly ready: true` ### TextRectUpdate Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextRectUpdate. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextRectUpdate } from "three-blocks/text"; interface TextRectUpdate ``` **Purpose:** Declares TextRectUpdate as a public interface. It is exported from three-blocks/text. Its declared surface covers id, rect, and type. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextRectUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly id: string` - `readonly rect: TextElementRect` - `readonly type: 'rect'` ### TextRemoveUpdate Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextRemoveUpdate. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextRemoveUpdate } from "three-blocks/text"; interface TextRemoveUpdate ``` **Purpose:** Declares TextRemoveUpdate as a public interface. It is exported from three-blocks/text. Its declared surface covers id and type. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextRemoveUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly id: string` - `readonly type: 'remove'` ### TextRenderer Kind: class; canonical: https://threejs-blocks.com/docs/api/TextRenderer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { TextRenderer } from "three-blocks/text/worker"; class TextRenderer ``` **Purpose:** Long-lived render-side text owner with incremental updates and atomic font/config swaps. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `applyBatch(batch: TextSyncBatch): boolean` - `applyDelivery(delivery: TextSyncDelivery): boolean` - `applySnapshot(batch: TextSyncBatch): boolean` - `get batchCount(): number` - `get configuration(): TextConfiguration` - `constructor(options: TextRendererOptions)` - `dispose(): Promise` - `replaceConfiguration(configuration: TextConfiguration): Promise`: Preload and build against a detached candidate; commit only after full validation. - `readonly resources: {fonts: Map;}`: Stable container for shader-precompile value addressing across configuration swaps. - `setViewport(width: number, height: number): void` - `get size(): number` - `whenReady(): Promise` ### TextRendererOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextRendererOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextRendererOptions } from "three-blocks/text/worker"; interface TextRendererOptions ``` **Purpose:** Declares TextRendererOptions as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers baseRenderOrder, configuration, createBatch, loadFont, and maxGlyphCountPerBatch, plus 11 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextRendererOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly baseRenderOrder?: number` - `readonly configuration: TextConfiguration` - `readonly createBatch?: (options: CreateTextBatchOptions) => TextBatch` - `readonly loadFont?: TextFontLoader` - `readonly maxGlyphCountPerBatch?: number` - `readonly maxTextCountPerBatch?: number` - `readonly onDiagnostic?: (diagnostic: MissingGlyphDiagnostic) => void` - `readonly onError?: (state: TextErrorState) => void` - `readonly onFallback?: (signal: TextFallbackSignal) => void` - `readonly onReady?: (state: TextReadyState) => void` - `readonly registerContainer?: (key: string, container: object) => void` - `readonly registerMaterial?: (key: string, material: object) => void` - `readonly renderer: unknown` - `readonly resolveUrl?: (url: string) => string` - `readonly scene: TextScene` - `readonly transcoderPath?: string` ### TextScene Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextScene. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextScene } from "three-blocks/text/worker"; interface TextScene ``` **Purpose:** Declares TextScene as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers add and remove. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextScene. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `add(object: object): unknown` - `remove(object: object): unknown` ### TextSync Kind: class; canonical: https://threejs-blocks.com/docs/api/TextSync. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { TextSync } from "three-blocks/text/main"; class TextSync ``` **Purpose:** Long-lived main-thread synchronizer. Replacing its publisher replays a complete snapshot. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, start, pause, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/text/main entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `add(element: Element): void` - `applyFallbackSignal(signal: TextFallbackSignal): void` - `constructor(options: TextSyncOptions)` - `dispose(): void` - `get disposed(): boolean` - `flush(): TextSyncDelivery | null` - `notifyScroll(): void` - `pause(): void` - `refresh(element: Element): void` - `refreshAll(): void` - `remove(element: Element): void` - `replay(): TextSyncDelivery` - `resume(): void` - `setPublisher(publisher: TextSyncPublisher, options?: {readonly replay?: boolean;}): void` - `get size(): number` - `snapshot(): TextSyncBatch` - `start(): Promise` - `get started(): boolean` ### TextSyncBatch Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextSyncBatch. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextSyncBatch } from "three-blocks/text"; interface TextSyncBatch ``` **Purpose:** Declares TextSyncBatch as a public interface. It is exported from three-blocks/text. Its declared surface covers canvasRect, schemaVersion, sequence, and updates. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextSyncBatch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly canvasRect: TextCanvasRect` - `readonly schemaVersion: typeof TEXT_SCHEMA_VERSION` - `readonly sequence: number` - `readonly updates: readonly TextElementUpdate[]` ### TextSyncDelivery Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextSyncDelivery. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextSyncDelivery } from "three-blocks/text"; interface TextSyncDelivery ``` **Purpose:** Declares TextSyncDelivery as a public interface. It is exported from three-blocks/text. Its declared surface covers batch and kind. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextSyncDelivery. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly batch: TextSyncBatch` - `readonly kind: 'batch' | 'snapshot'`: Incremental frame batches preserve rect-only scrolling; snapshots replace worker state. ### TextSyncEnvironment Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextSyncEnvironment. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextSyncEnvironment } from "three-blocks/text/main"; interface TextSyncEnvironment ``` **Purpose:** Declares TextSyncEnvironment as a public interface. It is exported from three-blocks/text/main. Its declared surface covers Element, IntersectionObserver, MutationObserver, Node, and NodeFilter, plus 6 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextSyncEnvironment. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/main entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly Element: typeof Element` - `readonly IntersectionObserver: typeof IntersectionObserver` - `readonly MutationObserver: typeof MutationObserver` - `readonly Node: typeof Node` - `readonly NodeFilter: typeof NodeFilter` - `readonly ResizeObserver: typeof ResizeObserver` - `readonly cancelAnimationFrame: (handle: number) => void` - `readonly document: Document` - `readonly getComputedStyle: typeof getComputedStyle` - `readonly requestAnimationFrame: (callback: FrameRequestCallback) => number` - `readonly window: Window` ### TextSyncOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextSyncOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextSyncOptions } from "three-blocks/text/main"; interface TextSyncOptions ``` **Purpose:** Declares TextSyncOptions as a public interface. It is exported from three-blocks/text/main. Its declared surface covers attribute, disabled, environment, fallbackAttribute, and fontAttribute, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextSyncOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/main entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly attribute?: string` - `readonly disabled?: boolean` - `readonly environment?: TextSyncEnvironment` - `readonly fallbackAttribute?: string` - `readonly fontAttribute?: string` - `readonly getCanvasRect?: () => TextCanvasRect` - `readonly idAttribute?: string` - `readonly maxCharacters?: number` - `readonly onFallbackChange?: (element: Element, visible: boolean, status: TextFallbackStatus) => void` - `readonly publish: TextSyncPublisher` - `readonly root?: ParentNode` - `readonly zIndexAttribute?: string` ### TextSyncPublisher Kind: type; canonical: https://threejs-blocks.com/docs/api/TextSyncPublisher. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextSyncPublisher } from "three-blocks/text/main"; type TextSyncPublisher = (delivery: TextSyncDelivery) => void ``` **Purpose:** Declares TextSyncPublisher as a public type. It is exported from three-blocks/text/main. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextSyncPublisher. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/main entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextTexture Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextTexture. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextTexture } from "three-blocks/text/worker"; interface TextTexture ``` **Purpose:** Declares TextTexture as a public interface. It is exported from three-blocks/text/worker. Its declared surface covers dispose and image. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose?(): void` - `readonly image?: {readonly width?: number; readonly height?: number;}` ### TextUnicodePreset Kind: type; canonical: https://threejs-blocks.com/docs/api/TextUnicodePreset. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextUnicodePreset } from "three-blocks/text"; type TextUnicodePreset = 'latin' | 'japanese-kana' ``` **Purpose:** Declares TextUnicodePreset as a public type. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextUnicodePreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TextUnicodeRange Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextUnicodeRange. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextUnicodeRange } from "three-blocks/text"; interface TextUnicodeRange ``` **Purpose:** Declares TextUnicodeRange as a public interface. It is exported from three-blocks/text. Its declared surface covers end and start. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextUnicodeRange. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly end: number` - `readonly start: number` ### TextVisibilityUpdate Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextVisibilityUpdate. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextVisibilityUpdate } from "three-blocks/text"; interface TextVisibilityUpdate ``` **Purpose:** Declares TextVisibilityUpdate as a public interface. It is exported from three-blocks/text. Its declared surface covers id, type, and visible. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextVisibilityUpdate. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly id: string` - `readonly type: 'visibility'` - `readonly visible: boolean` ### TextureAssetDefinition Kind: interface; canonical: https://threejs-blocks.com/docs/api/TextureAssetDefinition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TextureAssetDefinition } from "three-blocks/assets"; interface TextureAssetDefinition extends AssetDefinition<'texture', string, never> ``` **Purpose:** Declares TextureAssetDefinition as a public interface. It is exported from three-blocks/assets. Its declared surface covers colorSpace, format, and url. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TextureAssetDefinition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly colorSpace?: string` - `readonly format?: ImageAssetFormat | 'ktx2'` - `readonly url: string` ### ThreeAssetAdapterError Kind: class; canonical: https://threejs-blocks.com/docs/api/ThreeAssetAdapterError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ThreeAssetAdapterError } from "three-blocks/assets"; class ThreeAssetAdapterError extends Error ``` **Purpose:** Declares ThreeAssetAdapterError as a public class. It is exported from three-blocks/assets. Its declared surface covers causeValue, code, and url, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly causeValue: unknown` - `readonly code: ThreeAssetAdapterErrorCode` - `constructor(options: {readonly code: ThreeAssetAdapterErrorCode; readonly message: string; readonly url?: string; readonly cause?: unknown;})` - `readonly url: string | undefined` ### ThreeAssetAdapterErrorCode Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeAssetAdapterErrorCode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetAdapterErrorCode } from "three-blocks/assets"; type ThreeAssetAdapterErrorCode = 'aborted' | 'decode-failed' | 'fetch-failed' | 'invalid-data' | 'missing-codec' | 'runtime-unavailable' | 'unsupported-configuration' ``` **Purpose:** Declares ThreeAssetAdapterErrorCode as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetAdapterErrorCode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeAssetAdapterRuntime Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetAdapterRuntime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetAdapterRuntime } from "three-blocks/assets"; interface ThreeAssetAdapterRuntime ``` **Purpose:** Declares ThreeAssetAdapterRuntime as a public interface. It is exported from three-blocks/assets. Its declared surface covers adapters, dispose, disposed, and registry. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly adapters: ThreeStandardAssetAdapters` - `dispose(): Promise`: Dispose shared Draco/KTX2 worker pools after AssetManager shutdown completes. - `readonly disposed: boolean` - `readonly registry: ThreeAssetLoaderRegistry` ### ThreeAssetBitmap Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetBitmap. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetBitmap } from "three-blocks/assets"; interface ThreeAssetBitmap ``` **Purpose:** Minimal transferable image shape. Browser ImageBitmap satisfies this contract. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: close. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `close?(): void` - `readonly height?: number` - `readonly width?: number` ### ThreeAssetCurvePluginFactory Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeAssetCurvePluginFactory. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetCurvePluginFactory } from "three-blocks/assets"; type ThreeAssetCurvePluginFactory = (parser: unknown, extensionName: string) => ThreeAssetGltfPlugin ``` **Purpose:** Declares ThreeAssetCurvePluginFactory as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetCurvePluginFactory. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeAssetDataTextureLoader Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetDataTextureLoader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetDataTextureLoader } from "three-blocks/assets"; interface ThreeAssetDataTextureLoader ``` **Purpose:** Declares ThreeAssetDataTextureLoader as a public interface. It is exported from three-blocks/assets. Its declared surface covers createDataTexture. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetDataTextureLoader. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `createDataTexture(buffer: ArrayBuffer): DataTexture` ### ThreeAssetDracoLoader Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetDracoLoader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetDracoLoader } from "three-blocks/assets"; interface ThreeAssetDracoLoader ``` **Purpose:** Declares ThreeAssetDracoLoader as a public interface. It is exported from three-blocks/assets. Its declared surface covers dispose and setDecoderPath. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(): unknown` - `setDecoderPath(path: string): this` ### ThreeAssetFetch Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeAssetFetch. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetFetch } from "three-blocks/assets"; type ThreeAssetFetch = (url: string, init: {readonly signal?: unknown;}) => PromiseLike ``` **Purpose:** Declares ThreeAssetFetch as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetFetch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeAssetFetchHeaders Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetFetchHeaders. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetFetchHeaders } from "three-blocks/assets"; interface ThreeAssetFetchHeaders ``` **Purpose:** Declares ThreeAssetFetchHeaders as a public interface. It is exported from three-blocks/assets. Its declared surface covers get. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetFetchHeaders. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `get(name: string): string | null` ### ThreeAssetFetchResponse Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetFetchResponse. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetFetchResponse } from "three-blocks/assets"; interface ThreeAssetFetchResponse ``` **Purpose:** Declares ThreeAssetFetchResponse as a public interface. It is exported from three-blocks/assets. Its declared surface covers arrayBuffer, body, headers, ok, and status, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetFetchResponse. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `arrayBuffer(): PromiseLike` - `readonly body?: ThreeAssetReadableBody | null` - `readonly headers?: ThreeAssetFetchHeaders` - `readonly ok: boolean` - `readonly status: number` - `readonly statusText?: string` ### ThreeAssetGltfLoader Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetGltfLoader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetGltfLoader } from "three-blocks/assets"; interface ThreeAssetGltfLoader ``` **Purpose:** Declares ThreeAssetGltfLoader as a public interface. It is exported from three-blocks/assets. Its declared surface covers parseAsync, register, setDRACOLoader, setKTX2Loader, and setMeshoptDecoder. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetGltfLoader. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `parseAsync(data: ArrayBuffer | string, path: string): PromiseLike` - `register(factory: (parser: unknown) => ThreeAssetGltfPlugin): this` - `setDRACOLoader(loader: ThreeAssetDracoLoader | null): this` - `setKTX2Loader(loader: ThreeAssetKtx2Loader | null): this` - `setMeshoptDecoder(decoder: ThreeBlocksMeshoptDecoder | null): this` ### ThreeAssetGltfPlugin Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetGltfPlugin. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetGltfPlugin } from "three-blocks/assets"; interface ThreeAssetGltfPlugin ``` **Purpose:** Declares ThreeAssetGltfPlugin as a public interface. It is exported from three-blocks/assets. Its declared surface covers afterRoot and name. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetGltfPlugin. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `afterRoot?(result: GLTF): PromiseLike | void | null` - `readonly name: string` ### ThreeAssetImageDecoder Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeAssetImageDecoder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetImageDecoder } from "three-blocks/assets"; type ThreeAssetImageDecoder = (bytes: Uint8Array, options: {readonly mimeType: string; readonly url: string; readonly signal: AbortSignalLike;}) => PromiseLike ``` **Purpose:** Declares ThreeAssetImageDecoder as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetImageDecoder. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeAssetKtx2Loader Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetKtx2Loader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetKtx2Loader } from "three-blocks/assets"; interface ThreeAssetKtx2Loader ``` **Purpose:** Declares ThreeAssetKtx2Loader as a public interface. It is exported from three-blocks/assets. Its declared surface covers detectSupport, dispose, parse, and setTranscoderPath. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `detectSupport(renderer: unknown): this | PromiseLike` - `dispose(): unknown` - `parse(buffer: ArrayBuffer, onLoad: (texture: Texture) => void, onError: (error: unknown) => void): void` - `setTranscoderPath(path: string): this` ### ThreeAssetLoaderFactories Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetLoaderFactories. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetLoaderFactories } from "three-blocks/assets"; interface ThreeAssetLoaderFactories ``` **Purpose:** Declares ThreeAssetLoaderFactories as a public interface. It is exported from three-blocks/assets. Its declared surface covers draco, exr, gltf, hdr, and ktx2. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetLoaderFactories. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly draco?: () => ThreeAssetDracoLoader | PromiseLike` - `readonly exr?: () => ThreeAssetDataTextureLoader | PromiseLike` - `readonly gltf?: () => ThreeAssetGltfLoader | PromiseLike` - `readonly hdr?: () => ThreeAssetDataTextureLoader | PromiseLike` - `readonly ktx2?: () => ThreeAssetKtx2Loader | PromiseLike` ### ThreeAssetLoaderRegistry Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeAssetLoaderRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetLoaderRegistry } from "three-blocks/assets"; type ThreeAssetLoaderRegistry = AssetLoaderRegistry ``` **Purpose:** Declares ThreeAssetLoaderRegistry as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetLoaderRegistry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeAssetReadableBody Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetReadableBody. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetReadableBody } from "three-blocks/assets"; interface ThreeAssetReadableBody ``` **Purpose:** Declares ThreeAssetReadableBody as a public interface. It is exported from three-blocks/assets. Its declared surface covers getReader. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetReadableBody. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `getReader(): ThreeAssetStreamReader` ### ThreeAssetStreamReader Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetStreamReader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetStreamReader } from "three-blocks/assets"; interface ThreeAssetStreamReader ``` **Purpose:** Declares ThreeAssetStreamReader as a public interface. It is exported from three-blocks/assets. Its declared surface covers cancel, read, and releaseLock. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetStreamReader. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `cancel?(reason?: unknown): PromiseLike | unknown` - `read(): PromiseLike<{readonly done: boolean; readonly value?: Uint8Array;}>` - `releaseLock?(): void` ### ThreeAssetThreeModule Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeAssetThreeModule. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeAssetThreeModule } from "three-blocks/assets"; interface ThreeAssetThreeModule ``` **Purpose:** Declares ThreeAssetThreeModule as a public interface. It is exported from three-blocks/assets. Its declared surface covers CubeTexture, SRGBColorSpace, and Texture. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeAssetThreeModule. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly CubeTexture: new (images?: readonly unknown[]) => CubeTexture` - `readonly SRGBColorSpace: ColorSpace` - `readonly Texture: new (image?: unknown) => Texture` ### ThreeBlocksAssetBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksAssetBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksAssetBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksAssetBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksAssetBuildConfig ``` **Purpose:** Optimized-asset brief surfaced by the dev overlay (mirrors `.three-blocks/assets/meta.json`). **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksAssetBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly bytesIn: number` - `readonly bytesOut: number` - `readonly candidateBytes: number` - `readonly candidates: number` - `readonly kinds: Readonly>`: Fresh entries per source kind, so the overlay can name what was compressed. - `readonly optimized: number` - `readonly reason: string` - `readonly stale: number` - `readonly state: 'empty' | 'fresh' | 'stale' | 'invalid'` - `readonly vramBytesIn: number`: Exact GPU allocation totals from the optimizer's per-mip block math. - `readonly vramBytesOut: number` ### ThreeBlocksAssetReceipt Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksAssetReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksAssetReceipt } from "three-blocks/vite"; import type { ThreeBlocksAssetReceipt } from "three-blocks/vite/config"; interface ThreeBlocksAssetReceipt ``` **Purpose:** Declares ThreeBlocksAssetReceipt as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers draco, ktx2, and meshopt. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksAssetReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly draco: 'ready' | 'disabled'` - `readonly ktx2: 'ready' | 'disabled'` - `readonly meshopt: 'lazy' | 'disabled'` ### ThreeBlocksBuildReceipt Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksBuildReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksBuildReceipt } from "three-blocks/vite"; import type { ThreeBlocksBuildReceipt } from "three-blocks/vite/config"; interface ThreeBlocksBuildReceipt ``` **Purpose:** Stable machine-readable state behind the terminal build receipt. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksBuildReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assets: ThreeBlocksAssetReceipt` - `readonly output: string` - `readonly renderer: ThreeBlocksRendererReceipt` - `readonly schemaVersion: typeof THREE_BLOCKS_VITE_SCHEMA_VERSION` - `readonly shaders: ThreeBlocksShaderReceipt` - `readonly stats: ThreeBlocksStatsBuildConfig` - `readonly text?: ThreeBlocksTextReceipt` - `readonly threeVersion: string` ### ThreeBlocksClientConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksClientConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksClientConfig } from "three-blocks/vite"; import type { ThreeBlocksClientConfig } from "three-blocks/vite/config"; interface ThreeBlocksClientConfig ``` **Purpose:** Compile-time state available to browser and worker modules. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksClientConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assets: ThreeBlocksAssetBuildConfig` - `readonly base: string` - `readonly capture?: ThreeBlocksShaderCaptureBuildConfig`: Development-only overlay capture transport. - `readonly codecs: ThreeBlocksCodecRuntimeConfig` - `readonly command: ThreeBlocksViteCommand` - `readonly development: boolean` - `readonly mode: string` - `readonly project?: {readonly storageKey: string;}`: Opaque discriminator used only to namespace browser-local development preferences. - `readonly receipt: ThreeBlocksBuildReceipt` - `readonly renderer: ThreeBlocksRendererReceipt` - `readonly schemaVersion: typeof THREE_BLOCKS_VITE_SCHEMA_VERSION` - `readonly shaders: ThreeBlocksShaderBuildConfig` - `readonly stats: ThreeBlocksStatsBuildConfig` - `readonly text: ThreeBlocksTextBuildConfig` - `readonly threeVersion: string` ### ThreeBlocksCodecOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksCodecOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksCodecOptions } from "three-blocks/vite"; interface ThreeBlocksCodecOptions ``` **Purpose:** Declares ThreeBlocksCodecOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers draco, ktx2, meshopt, and outputDirectory. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksCodecOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly draco?: boolean`: Emit and serve the glTF Draco decoder. Defaults to true. - `readonly ktx2?: boolean`: Emit and serve the Basis/KTX2 transcoder. Defaults to true. - `readonly meshopt?: boolean`: Expose the Meshopt decoder through a lazy Three.js module import. Defaults to true. - `readonly outputDirectory?: string`: Relative output directory. Defaults to `_three-blocks/codecs`. ### ThreeBlocksCodecRuntimeConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksCodecRuntimeConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksCodecRuntimeConfig } from "three-blocks/vite"; import type { ThreeBlocksCodecRuntimeConfig } from "three-blocks/vite/config"; interface ThreeBlocksCodecRuntimeConfig ``` **Purpose:** Declares ThreeBlocksCodecRuntimeConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers draco, ktx2, and meshopt. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksCodecRuntimeConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly draco: false | ThreeBlocksDracoRuntime` - `readonly ktx2: false | ThreeBlocksKtx2Runtime` - `readonly meshopt: false | ThreeBlocksMeshoptRuntime` ### ThreeBlocksDracoRuntime Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksDracoRuntime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksDracoRuntime } from "three-blocks/vite"; import type { ThreeBlocksDracoRuntime } from "three-blocks/vite/config"; interface ThreeBlocksDracoRuntime ``` **Purpose:** Declares ThreeBlocksDracoRuntime as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers decoderPath and files. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksDracoRuntime. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly decoderPath: string` - `readonly files: readonly ['draco_decoder.js', 'draco_decoder.wasm', 'draco_wasm_wrapper.js']` ### ThreeBlocksKtx2Runtime Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksKtx2Runtime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksKtx2Runtime } from "three-blocks/vite"; import type { ThreeBlocksKtx2Runtime } from "three-blocks/vite/config"; interface ThreeBlocksKtx2Runtime ``` **Purpose:** Declares ThreeBlocksKtx2Runtime as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers files and transcoderPath. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksKtx2Runtime. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly files: readonly ['basis_transcoder.js', 'basis_transcoder.wasm']` - `readonly transcoderPath: string` ### ThreeBlocksMeshoptDecoder Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksMeshoptDecoder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksMeshoptDecoder } from "three-blocks/vite"; import type { ThreeBlocksMeshoptDecoder } from "three-blocks/vite/config"; interface ThreeBlocksMeshoptDecoder ``` **Purpose:** Structural contract returned from Three.js' lazy Meshopt module. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksMeshoptDecoder. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `decodeGltfBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string): void` - `decodeGltfBufferAsync(count: number, size: number, source: Uint8Array, mode: string, filter?: string): Promise` - `decodeIndexBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array): void` - `decodeIndexSequence(target: Uint8Array, count: number, size: number, source: Uint8Array): void` - `decodeVertexBuffer(target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string): void` - `readonly ready: Promise` - `readonly supported: boolean` - `useWorkers(count: number): void` ### ThreeBlocksMeshoptRuntime Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksMeshoptRuntime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksMeshoptRuntime } from "three-blocks/vite"; import type { ThreeBlocksMeshoptRuntime } from "three-blocks/vite/config"; interface ThreeBlocksMeshoptRuntime ``` **Purpose:** Declares ThreeBlocksMeshoptRuntime as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers specifier and strategy. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksMeshoptRuntime. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly specifier: 'three/addons/libs/meshopt_decoder.module.js'` - `readonly strategy: 'lazy-module'` ### ThreeBlocksOverlayOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksOverlayOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksOverlayOptions } from "three-blocks/vite"; interface ThreeBlocksOverlayOptions ``` **Purpose:** Declares ThreeBlocksOverlayOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers position and production. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksOverlayOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly position?: ThreeBlocksOverlayPosition`: Screen corner for the Logo chip. Defaults to `bottom-left`. - `readonly production?: boolean`: Keep the overlay in production builds, in showcase mode (no development-only HMR guidance). Off by default — intended for published demos and showcases, not end-user applications. ### ThreeBlocksOverlayPosition Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksOverlayPosition. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksOverlayPosition } from "three-blocks/vite"; type ThreeBlocksOverlayPosition = 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right' ``` **Purpose:** Declares ThreeBlocksOverlayPosition as a public type. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksOverlayPosition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksProjectInspection Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksProjectInspection. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksProjectInspection } from "three-blocks/vite"; interface ThreeBlocksProjectInspection ``` **Purpose:** Declares ThreeBlocksProjectInspection as a public interface. It is exported from three-blocks/vite. Its declared surface covers assets, shaders, and text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksProjectInspection. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly assets: ThreeBlocksAssetInspection` - `readonly shaders: ThreeBlocksShaderInspection` - `readonly text?: ThreeBlocksTextInspection` ### ThreeBlocksReadiness Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksReadiness. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksReadiness } from "three-blocks/app"; interface ThreeBlocksReadiness ``` **Purpose:** Declares ThreeBlocksReadiness as a public interface. It is exported from three-blocks/app. Its declared surface covers assetsReady, compileEnd, firstFrame, loadEnd, and textReady, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksReadiness. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `assetsReady: boolean` - `compileEnd: boolean` - `firstFrame: boolean` - `loadEnd: boolean` - `textReady: boolean` - `worker: boolean` - `workerReady: boolean` ### ThreeBlocksReceiptOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksReceiptOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksReceiptOptions } from "three-blocks/vite"; interface ThreeBlocksReceiptOptions ``` **Purpose:** Declares ThreeBlocksReceiptOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers onBuild and print. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksReceiptOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly onBuild?: (receipt: ThreeBlocksBuildReceipt) => void`: Receive the same stable state printed in the terminal. - `readonly print?: boolean`: Print the final receipt after a successful production bundle. Defaults to true. ### ThreeBlocksRendererOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksRendererOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksRendererOptions } from "three-blocks/vite"; interface ThreeBlocksRendererOptions ``` **Purpose:** Declares ThreeBlocksRendererOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers owner. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksRendererOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly owner?: ThreeBlocksRendererReceipt['owner']`: Rendering execution owner. Inferred as worker for scaffolds and page otherwise. ### ThreeBlocksRendererReceipt Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksRendererReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksRendererReceipt } from "three-blocks/vite"; import type { ThreeBlocksRendererReceipt } from "three-blocks/vite/config"; interface ThreeBlocksRendererReceipt ``` **Purpose:** Declares ThreeBlocksRendererReceipt as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers api, fallback, and owner. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksRendererReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly api: 'WebGPU'` - `readonly fallback: 'WebGL'` - `readonly owner: 'page' | 'worker'` ### ThreeBlocksShaderBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksShaderBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksShaderBuildConfig ``` **Purpose:** Declares ThreeBlocksShaderBuildConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers changed, enabled, mode, pipelines, and scenes, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changed: readonly string[]` - `readonly enabled: boolean`: False when shader inspection and precompile guidance are intentionally disabled. - `readonly mode: 'precompiled' | 'live'` - `readonly pipelines: number` - `readonly scenes?: Readonly>`: Optional per-scene detail lets the overlay report the route being viewed. - `readonly state: ThreeBlocksShaderState` - `readonly strict: boolean` ### ThreeBlocksShaderCaptureBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderCaptureBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderCaptureBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksShaderCaptureBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksShaderCaptureBuildConfig ``` **Purpose:** Declares ThreeBlocksShaderCaptureBuildConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers available, beginEndpoint, captureEndpoint, command, and readiness, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderCaptureBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly available: boolean` - `readonly beginEndpoint: string` - `readonly captureEndpoint: string` - `readonly command: string` - `readonly readiness: {readonly selector?: string; readonly global?: string;}` - `readonly scenes: readonly string[]` - `readonly sessionKey: string` - `readonly settleFrames: number` - `readonly settleTimeoutMs: number` - `readonly telemetryEndpoint: string` - `readonly token?: string` - `readonly transform: number` ### ThreeBlocksShaderInspection Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderInspection. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderInspection } from "three-blocks/vite"; interface ThreeBlocksShaderInspection ``` **Purpose:** Declares ThreeBlocksShaderInspection as a public interface. It is exported from three-blocks/vite. Its declared surface covers changed, pipelines, reason, scenes, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderInspection. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changed: readonly string[]` - `readonly pipelines: number` - `readonly reason: string` - `readonly scenes?: Readonly>` - `readonly state: ThreeBlocksShaderState` ### ThreeBlocksShaderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderOptions } from "three-blocks/vite"; interface ThreeBlocksShaderOptions ``` **Purpose:** Declares ThreeBlocksShaderOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers changed, pipelines, refresh, scenes, and state, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changed?: readonly string[]` - `readonly pipelines?: number` - `readonly refresh?: () => Promise` - `readonly scenes?: Readonly>` - `readonly state?: ThreeBlocksShaderState` - `readonly strict?: boolean`: Fail a production build unless the manifest is fresh. ### ThreeBlocksShaderReceipt Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderReceipt } from "three-blocks/vite"; import type { ThreeBlocksShaderReceipt } from "three-blocks/vite/config"; interface ThreeBlocksShaderReceipt ``` **Purpose:** Declares ThreeBlocksShaderReceipt as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers enabled, mode, pipelines, state, and timing, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly enabled?: boolean` - `readonly mode: 'precompiled' | 'live'` - `readonly pipelines: number` - `readonly state: ThreeBlocksShaderState` - `readonly timing?: ThreeBlocksShaderTiming` - `readonly verification?: ThreeBlocksShaderVerification` ### ThreeBlocksShaderRefreshResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderRefreshResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderRefreshResult } from "three-blocks/vite"; interface ThreeBlocksShaderRefreshResult ``` **Purpose:** Declares ThreeBlocksShaderRefreshResult as a public interface. It is exported from three-blocks/vite. Its declared surface covers changed, pipelines, scenes, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderRefreshResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changed?: readonly string[]` - `readonly pipelines?: number` - `readonly scenes?: Readonly>` - `readonly state: ThreeBlocksShaderState` ### ThreeBlocksShaderRuntimeSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderRuntimeSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderRuntimeSnapshot } from "three-blocks/app"; interface ThreeBlocksShaderRuntimeSnapshot ``` **Purpose:** Live shader-provider counters exposed to the development overlay. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderRuntimeSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly hydrationMs?: number` - `readonly injected: number` - `readonly live: number` - `readonly maxHydrationMs?: number` - `readonly missed: number` ### ThreeBlocksShaderSceneBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderSceneBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderSceneBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksShaderSceneBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksShaderSceneBuildConfig ``` **Purpose:** Declares ThreeBlocksShaderSceneBuildConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers changed, moduleBytes, pipelines, state, and timing, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderSceneBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly changed?: readonly string[]` - `readonly moduleBytes?: number`: UTF-8 bytes in the manifest's pooled WGSL or GLSL programs. - `readonly pipelines: number` - `readonly state?: Exclude` - `readonly timing?: ThreeBlocksShaderTiming`: Receipt-matched build timing from the latest successful browser capture. - `readonly verification?: ThreeBlocksShaderVerification` ### ThreeBlocksShaderState Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderState } from "three-blocks/vite"; import type { ThreeBlocksShaderState } from "three-blocks/vite/config"; type ThreeBlocksShaderState = 'fresh' | 'stale' | 'invalid' | 'missing' | 'not-observed' ``` **Purpose:** Declares ThreeBlocksShaderState as a public type. It is exported from three-blocks/vite and three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksShaderTiming Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderTiming. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksShaderTiming } from "three-blocks/vite"; import type { ThreeBlocksShaderTiming } from "three-blocks/vite/config"; interface ThreeBlocksShaderTiming ``` **Purpose:** Declares ThreeBlocksShaderTiming as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers adapter, avoidedBuildMs, builds, liveBuildMs, and measuredAt, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderTiming. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly adapter?: string` - `readonly avoidedBuildMs: number` - `readonly builds?: number`: Receipt-matched NodeBuilder invocations represented by this timing. - `readonly liveBuildMs: number` - `readonly measuredAt: string` - `readonly platform?: string` - `readonly precompiledBuildMs: number` - `readonly runs?: number` - `readonly schemaVersion?: 3` - `readonly setupMeasured?: boolean`: True when the A/B measured and subtracted precompiled setup and hydration. - `readonly source: 'latest-local-capture' | 'committed-capture'` - `readonly spreadMs?: number` ### ThreeBlocksShaderVerification Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksShaderVerification. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: Read-only/input compatibility for timing captured before schema version 3. ```ts import type { ThreeBlocksShaderVerification } from "three-blocks/vite"; import type { ThreeBlocksShaderVerification } from "three-blocks/vite/config"; interface ThreeBlocksShaderVerification ``` **Purpose:** Declares ThreeBlocksShaderVerification as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers adapter, avoidedBuildMs, liveBuildMs, measuredAt, and platform, plus 5 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Deprecated public API: Read-only/input compatibility for timing captured before schema version 3. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksShaderVerification. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly adapter?: string` - `readonly avoidedBuildMs: number` - `readonly liveBuildMs: number` - `readonly measuredAt: string` - `readonly platform?: string` - `readonly precompiledBuildMs: number` - `readonly runs?: number` - `readonly schemaVersion?: 1 | 2` - `readonly source: 'local-ab' | 'committed-ab'` - `readonly spreadMs?: number` ### ThreeBlocksSmokeState Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksSmokeState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksSmokeState } from "three-blocks/app"; interface ThreeBlocksSmokeState ``` **Purpose:** Declares ThreeBlocksSmokeState as a public interface. It is exported from three-blocks/app. Its declared surface covers announce, diagnostics, owner, protocolVersion, and readiness, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksSmokeState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly announce?: boolean`: False when the owning registration opted out of its one-time dev announcement. - `diagnostics?: {workerId: string; width: number; height: number; scrollPosition: number; visible: boolean; shaderMode: 'precompiled' | 'live';}` - `readonly owner: 'page' | 'worker'` - `readonly protocolVersion: 1` - `readonly readiness: ThreeBlocksReadiness` - `readonly renderer?: {readonly api: 'Three.js' | 'WebGL' | 'WebGPU';}` - `readonly restart: {count: number; canvasReplaced: boolean; stateReplayed: boolean; lastReason: string;}` - `restartWorker(reason?: string): Promise` - `readonly shaders?: ThreeBlocksShaderRuntimeSnapshot | undefined`: Present while a shader provider or live-build observer is installed. - `readonly stats: {readonly snapshots: number; readonly textures: number; /** Requested panel visibility. Hidden documents temporarily suppress the DOM panel. */ readonly panelVisible: boolean; /** Optional page-owned counters rendered directly inside the devtools overlay. */ readonly metrics?: Readonly>; setPanelVisible(visible: boolean): Promise; setPanelMode(mode: Exclude): Promise;}` - `readonly tsl?: ThreeBlocksTslBuildSnapshot | undefined`: Present when development NodeBuilder timing is available. - `readonly worker: {offscreenCanvas: boolean; visible: boolean; generation: number;}` ### ThreeBlocksStatsBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksStatsBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksStatsBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksStatsBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksStatsBuildConfig ``` **Purpose:** Declares ThreeBlocksStatsBuildConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers enabled and production. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksStatsBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly enabled: boolean` - `readonly production: boolean` ### ThreeBlocksStatsOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksStatsOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksStatsOptions } from "three-blocks/vite"; interface ThreeBlocksStatsOptions ``` **Purpose:** Declares ThreeBlocksStatsOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers development and production. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksStatsOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly development?: boolean`: Defaults to true for the development server. - `readonly production?: boolean`: Defaults to false for production builds. ### ThreeBlocksTextBuildConfig Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTextBuildConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTextBuildConfig } from "three-blocks/vite"; import type { ThreeBlocksTextBuildConfig } from "three-blocks/vite/config"; interface ThreeBlocksTextBuildConfig ``` **Purpose:** Declares ThreeBlocksTextBuildConfig as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers atlases, enabled, glyphs, missing, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTextBuildConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlases: number` - `readonly enabled: boolean` - `readonly glyphs: number` - `readonly missing: readonly number[]` - `readonly state: ThreeBlocksTextState` ### ThreeBlocksTextInspection Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTextInspection. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTextInspection } from "three-blocks/vite"; interface ThreeBlocksTextInspection ``` **Purpose:** Declares ThreeBlocksTextInspection as a public interface. It is exported from three-blocks/vite. Its declared surface covers atlases, glyphs, missing, reason, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTextInspection. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlases: number` - `readonly glyphs: number` - `readonly missing: readonly number[]` - `readonly reason: string` - `readonly state: Exclude` ### ThreeBlocksTextOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTextOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTextOptions } from "three-blocks/vite"; interface ThreeBlocksTextOptions ``` **Purpose:** Declares ThreeBlocksTextOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers atlases, configuration, enabled, generate, and glyphs, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTextOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlases?: number` - `readonly configuration?: TextConfiguration`: Static public text configuration used for no-GPU coverage and checksum inspection. - `readonly enabled?: boolean` - `readonly generate?: false | {readonly command?: string; readonly args?: readonly string[];}`: Missing-glyph command used by the development server. Defaults to `three-blocks text generate`; false disables automatic generation. - `readonly glyphs?: number` - `readonly state?: Exclude`: Result from the public text artifact inspection. ### ThreeBlocksTextReceipt Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTextReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTextReceipt } from "three-blocks/vite"; import type { ThreeBlocksTextReceipt } from "three-blocks/vite/config"; interface ThreeBlocksTextReceipt ``` **Purpose:** Declares ThreeBlocksTextReceipt as a public interface. It is exported from three-blocks/vite and three-blocks/vite/config. Its declared surface covers atlases, glyphs, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTextReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly atlases: number` - `readonly glyphs: number` - `readonly state: Exclude` ### ThreeBlocksTextState Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTextState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTextState } from "three-blocks/vite"; import type { ThreeBlocksTextState } from "three-blocks/vite/config"; type ThreeBlocksTextState = 'disabled' | 'ready' | 'generating' | 'fallback' | 'stale' | 'invalid' | 'missing' | 'not-observed' ``` **Purpose:** Declares ThreeBlocksTextState as a public type. It is exported from three-blocks/vite and three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTextState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksTslBuildObserver Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTslBuildObserver. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTslBuildObserver } from "three-blocks/devtools"; interface ThreeBlocksTslBuildObserver ``` **Purpose:** Declares ThreeBlocksTslBuildObserver as a public interface. It is exported from three-blocks/devtools. Its declared surface covers dispose, freezeFirstLoad, and snapshot. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `dispose(): void` - `freezeFirstLoad(): void` - `readonly snapshot: ThreeBlocksTslBuildSnapshot` ### ThreeBlocksTslBuildSnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksTslBuildSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksTslBuildSnapshot } from "three-blocks/app"; import type { ThreeBlocksTslBuildSnapshot } from "three-blocks/devtools"; interface ThreeBlocksTslBuildSnapshot ``` **Purpose:** Renderer-local NodeBuilder work observed during the current development session. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksTslBuildSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app and three-blocks/devtools entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly asyncBuildElapsedMs?: number`: `buildAsync()` wall time, including time yielded between build stages. - `readonly buildMs: number` - `readonly builds: number` - `readonly firstLoadAsyncBuildElapsedMs?: number` - `readonly firstLoadBuildMs: number` - `readonly firstLoadMaxPrecompiledSetupMs?: number` - `readonly firstLoadMaxSyncBuildMs?: number` - `readonly firstLoadPrecompiledSetupMs?: number` - `readonly firstLoadSyncBuildMs?: number` - `readonly maxPrecompiledSetupMs?: number`: Longest synchronous `prepareForHydration()` call. - `readonly maxSyncBuildMs?: number`: Longest synchronous `build()` call. - `readonly precompiledSetupMs?: number`: Synchronous setup retained by precompiled-state hydration. - `readonly syncBuildMs?: number`: Synchronous `build()` time. These calls block their owning thread. ### ThreeBlocksViteCommand Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksViteCommand. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksViteCommand } from "three-blocks/vite"; import type { ThreeBlocksViteCommand } from "three-blocks/vite/config"; type ThreeBlocksViteCommand = 'serve' | 'build' ``` **Purpose:** Declares ThreeBlocksViteCommand as a public type. It is exported from three-blocks/vite and three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksViteCommand. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite and three-blocks/vite/config entry points. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksViteError Kind: class; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksViteError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ThreeBlocksViteError } from "three-blocks/vite"; class ThreeBlocksViteError extends Error ``` **Purpose:** Actionable configuration or installed-package failure. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly causeValue: unknown` - `readonly code: ThreeBlocksViteErrorCode` - `constructor(code: ThreeBlocksViteErrorCode, message: string, causeValue?: unknown)` ### ThreeBlocksViteErrorCode Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksViteErrorCode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksViteErrorCode } from "three-blocks/vite"; type ThreeBlocksViteErrorCode = 'CONFIG_INVALID' | 'THREE_NOT_FOUND' | 'THREE_INCOMPATIBLE' | 'CODEC_MISSING' | 'STATS_NOT_FOUND' | 'THREE_CODEC_INCOMPATIBLE' | 'THREE_HOOK_INCOMPATIBLE' ``` **Purpose:** Declares ThreeBlocksViteErrorCode as a public type. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksViteErrorCode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksViteOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksViteOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksViteOptions } from "three-blocks/vite"; interface ThreeBlocksViteOptions ``` **Purpose:** Declares ThreeBlocksViteOptions as a public interface. It is exported from three-blocks/vite. Its declared surface covers codecs, overlay, receipt, renderer, and shaders, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksViteOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly codecs?: false | ThreeBlocksCodecOptions` - `readonly overlay?: boolean | ThreeBlocksOverlayOptions`: The in-page dev overlay (Logo chip → live status panel). Development server by default; `overlay.production` opts a build into the same surface for demos and showcases. `?tbOverlay=0` disables it per page. Defaults to enabled in development only. - `readonly receipt?: ThreeBlocksReceiptOptions` - `readonly renderer?: ThreeBlocksRendererOptions`: Rendering execution owner used by receipts, the overlay, and worker HMR. - `readonly shaders?: false | ThreeBlocksShaderOptions`: Shader inspection/precompile integration. False keeps adopted plain Three.js projects neutral. - `readonly stats?: boolean | ThreeBlocksStatsOptions` - `readonly text?: boolean | ThreeBlocksTextOptions` ### ThreeBlocksVitePlugin Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksVitePlugin. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksVitePlugin } from "three-blocks/vite"; type ThreeBlocksVitePlugin = Plugin & {readonly api: ThreeBlocksVitePluginApi;} ``` **Purpose:** Declares ThreeBlocksVitePlugin as a public type. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksVitePlugin. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeBlocksVitePluginApi Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeBlocksVitePluginApi. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeBlocksVitePluginApi } from "three-blocks/vite"; interface ThreeBlocksVitePluginApi ``` **Purpose:** Declares ThreeBlocksVitePluginApi as a public interface. It is exported from three-blocks/vite. Its declared surface covers getBuildReceipt and getClientConfig. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeBlocksVitePluginApi. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly getBuildReceipt: () => ThreeBlocksBuildReceipt | undefined` - `readonly getClientConfig: () => ThreeBlocksClientConfig | undefined` ### ThreeCaptureInstrumentationResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeCaptureInstrumentationResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeCaptureInstrumentationResult } from "three-blocks/vite"; interface ThreeCaptureInstrumentationResult ``` **Purpose:** Declares ThreeCaptureInstrumentationResult as a public interface. It is exported from three-blocks/vite. Its declared surface covers code and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeCaptureInstrumentationResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code: string` - `readonly state: 'applied' | 'already-applied'` ### ThreeCodecLoaderTransformResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeCodecLoaderTransformResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeCodecLoaderTransformResult } from "three-blocks/vite"; interface ThreeCodecLoaderTransformResult ``` **Purpose:** Declares ThreeCodecLoaderTransformResult as a public interface. It is exported from three-blocks/vite. Its declared surface covers code and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeCodecLoaderTransformResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code: string` - `readonly state: 'applied' | 'already-applied'` ### ThreeComponent Kind: class; canonical: https://threejs-blocks.com/docs/api/ThreeComponent. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { ThreeComponent } from "three-blocks/hmr"; abstract class ThreeComponent extends Object3D ``` **Purpose:** Explicit post-construction lifecycle. Class fields are initialized before `mount` runs; base constructors never call an overridable lifecycle method. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: mount and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `captureHotState?(): THotState` - `abstract dispose(): MaybePromise` - `abstract mount(context: TContext, options: TOptions): MaybePromise` - `restoreHotState?(state: THotState): MaybePromise` ### ThreeComponentClass Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeComponentClass. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeComponentClass } from "three-blocks/hmr"; type ThreeComponentClass = ThreeComponent> = new () => TComponent ``` **Purpose:** Declares ThreeComponentClass as a public type. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeComponentClass. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeProviderHookTransformResult Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeProviderHookTransformResult. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeProviderHookTransformResult } from "three-blocks/vite"; interface ThreeProviderHookTransformResult ``` **Purpose:** Declares ThreeProviderHookTransformResult as a public interface. It is exported from three-blocks/vite. Its declared surface covers code and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeProviderHookTransformResult. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code: string` - `readonly state: 'applied' | 'already-applied'` ### ThreeStandardAssetAdapters Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeStandardAssetAdapters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeStandardAssetAdapters } from "three-blocks/assets"; type ThreeStandardAssetAdapters = StandardAssetAdapters ``` **Purpose:** Declares ThreeStandardAssetAdapters as a public type. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeStandardAssetAdapters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeStandardAssetResultMap Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeStandardAssetResultMap. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeStandardAssetResultMap } from "three-blocks/assets"; interface ThreeStandardAssetResultMap ``` **Purpose:** Declares ThreeStandardAssetResultMap as a public interface. It is exported from three-blocks/assets. Its declared surface covers audio, binary, cubeTexture, exr, and font, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeStandardAssetResultMap. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly audio: ArrayBuffer` - `readonly binary: ArrayBuffer` - `readonly cubeTexture: CubeTexture` - `readonly exr: DataTexture` - `readonly font: ArrayBuffer` - `readonly glb: GLTF` - `readonly gltf: GLTF` - `readonly hdr: DataTexture` - `readonly image: Texture` - `readonly json: unknown` - `readonly ktx2: Texture` - `readonly texture: Texture` ### ThreeWebGPUCompatibilityOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeWebGPUCompatibilityOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeWebGPUCompatibilityOptions } from "three-blocks/shaders"; interface ThreeWebGPUCompatibilityOptions ``` **Purpose:** Declares ThreeWebGPUCompatibilityOptions as a public interface. It is exported from three-blocks/shaders. Its declared surface covers recipes and threeVersion. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeWebGPUCompatibilityOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly recipes?: Readonly>` - `readonly threeVersion: string`: Exact runtime version provided by `three-blocks/vite/config`. ### ThreeWebGPURecipe Kind: type; canonical: https://threejs-blocks.com/docs/api/ThreeWebGPURecipe. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeWebGPURecipe } from "three-blocks/shaders"; type ThreeWebGPURecipe = (context: ThreeWebGPURecipeContext) => ShaderNodeLike ``` **Purpose:** Declares ThreeWebGPURecipe as a public type. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeWebGPURecipe. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### ThreeWebGPURecipeContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/ThreeWebGPURecipeContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ThreeWebGPURecipeContext } from "three-blocks/shaders"; interface ThreeWebGPURecipeContext ``` **Purpose:** Declares ThreeWebGPURecipeContext as a public interface. It is exported from three-blocks/shaders. Its declared surface covers address and context. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ThreeWebGPURecipeContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly address: Extract` - `readonly context: ShaderAddressContext` ### TransferableValue Kind: type; canonical: https://threejs-blocks.com/docs/api/TransferableValue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TransferableValue } from "three-blocks/worker"; type TransferableValue = TValue & {readonly [TRANSFERABLE_VALUE]: true;} ``` **Purpose:** Explicitly marks an opaque host value that is sent once through a transfer list. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TransferableValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### TriggerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/TriggerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { TriggerOptions } from "three-blocks/runtime"; interface TriggerOptions ``` **Purpose:** Declares TriggerOptions as a public interface. It is exported from three-blocks/runtime. Its declared surface covers fireAtStart. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for TriggerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly fireAtStart?: boolean`: Retain the latest payload and replay it to future listeners and components. ### VAVBase Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVBase. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVBase } from "three-blocks/experimental/vertex-animation-video"; type VAVBase = VAVBaseImplementation ``` **Purpose:** Parsed index and optional UV arrays from a VAV `base.bin` topology sidecar. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVBase. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVManifest } from "three-blocks/experimental/vertex-animation-video"; type VAVManifest = Readonly ``` **Purpose:** Validated Vertex Animation Video runtime manifest. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMesh Kind: variable; canonical: https://threejs-blocks.com/docs/api/VAVMesh. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { VAVMesh } from "three-blocks/experimental/vertex-animation-video"; const VAVMesh: VAVMeshConstructor ``` **Purpose:** Runtime-only Vertex Animation Video mesh facade. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, pause, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: https://threejs-blocks.com/examples/webgpu_vav_basic. - `readonly appearance: VAVMeshAppearance`: Appearance-track family selected at construction. - `bufferedSecondsAhead(): number`: Seconds of contiguous media currently buffered ahead of the playhead. - `new (manifest: VAVManifest, base: VAVBase, options?: VAVMeshOptions): VAVMesh` - `dispose(): void`: Abort streams and release decoders, decoded frames, textures, and geometry. Idempotent; the inherited material is never disposed and remains the caller's responsibility. - `readonly duration: number`: Clip duration in seconds. - `readonly firstFrame: Promise`: Resolves after the first decoded frame reaches the GPU, or with `null` after early disposal. - `getDiagnostics(): Readonly`: Snapshot numerical binary and optional UV media-decoder state. - `readonly isBuffering: boolean`: Whether playback is currently stalled waiting for streamed bytes. - `loop: boolean`: Whether playback wraps after the final frame. - `readonly manifest: VAVManifest`: Validated immutable clip manifest. - `minBufferedSeconds: number`: Buffered duration required before starting or resuming after a stall. - `pause(): void`: Pause playback while retaining the current decoded frame pair. - `play(): void`: Begin or resume playback; advancement remains gated by the stream cushion. - `playbackSpeed: number`: Playback time multiplier. - `readonly playing: boolean`: Whether `update()` is allowed to advance the playback clock. - `registerIrradiance(material: TMaterial): TMaterial`: Wire an indirect-only baked GI output into a borrowed lit NodeMaterial. - `registerMaterial(material: TMaterial): TMaterial`: Wire animated position and normal outputs into a borrowed NodeMaterial. - `resume(): Promise`: Recreate released decoders and continue suspended streams. - `setTime(seconds: number): void`: Scrub to a time in seconds, clamped to the clip duration. - `suspend(): void`: Release requests and decoders while retaining the presented mesh and texture slots. - `readonly time: number`: Current playback time in seconds. - `update(deltaSeconds: number): void`: Advance playback by elapsed seconds. Call once after input/control updates and before the frame is rendered; a buffering clip holds time until every track has enough data. ### VAVMeshAppearance Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVMeshAppearance. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshAppearance } from "three-blocks/experimental/vertex-animation-video"; type VAVMeshAppearance = 'auto' | 'uv' | 'vertex' ``` **Purpose:** Appearance source selected when a clip contains both vertex and UV media. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshAppearance. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMeshDiagnostics Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVMeshDiagnostics. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshDiagnostics } from "three-blocks/experimental/vertex-animation-video"; type VAVMeshDiagnostics = VAVMeshDiagnosticsImplementation ``` **Purpose:** Snapshot of VAV numerical decoding and optional UV media-decoder state. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshDiagnostics. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMeshFetch Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVMeshFetch. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshFetch } from "three-blocks/experimental/vertex-animation-video"; type VAVMeshFetch = (input: string, init?: RequestInit) => PromiseLike ``` **Purpose:** Injectable network function used by VAVMesh.load. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshFetch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMeshFetchResponse Kind: interface; canonical: https://threejs-blocks.com/docs/api/VAVMeshFetchResponse. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshFetchResponse } from "three-blocks/experimental/vertex-animation-video"; interface VAVMeshFetchResponse extends VAVTrackFetchResponse ``` **Purpose:** Fetch response required while opening a manifest and topology sidecar. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshFetchResponse. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `arrayBuffer(): Promise`: Read a topology sidecar response. - `json(): Promise`: Read and decode a JSON manifest response. ### VAVMeshFileResolver Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVMeshFileResolver. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshFileResolver } from "three-blocks/experimental/vertex-animation-video"; type VAVMeshFileResolver = (file: string) => string ``` **Purpose:** Manifest-relative path resolver used by direct VAV construction. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshFileResolver. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMeshFiles Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVMeshFiles. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshFiles } from "three-blocks/experimental/vertex-animation-video"; type VAVMeshFiles = Map | Record ``` **Purpose:** Manifest-relative in-memory VAV package consumed by `loadFromFiles()`. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshFiles. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVMeshLoadOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VAVMeshLoadOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshLoadOptions } from "three-blocks/experimental/vertex-animation-video"; interface VAVMeshLoadOptions extends Omit ``` **Purpose:** Network-load options; URL resolution is owned by VAVMesh.load. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshLoadOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `fetchImpl?: VAVMeshFetch`: Fetch implementation used for the manifest, topology, and progressive tracks. ### VAVMeshOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VAVMeshOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVMeshOptions } from "three-blocks/experimental/vertex-animation-video"; interface VAVMeshOptions ``` **Purpose:** Runtime construction and playback options for VAVMesh. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVMeshOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `appearance?: VAVMeshAppearance`: Appearance-track family to load. - `fetchImpl?: VAVTrackFetch`: Streaming fetch implementation used by direct construction. - `loop?: boolean`: Whether playback wraps after the final frame. - `material?: THREE.NodeMaterial`: Borrowed NodeMaterial driven by the VAV geometry nodes; never disposed by the mesh. - `meshoptDecoder?: MeshoptVertexDecoderLike`: Meshopt vertex decoder for the UTSBM numerical tracks — pass `MeshoptDecoder` from `three/addons/libs/meshopt_decoder.module.js` (the same module `GLTFLoader` uses). - `minBufferedSeconds?: number`: Buffered duration required before starting or resuming a stalled stream. - `playbackSpeed?: number`: Playback time multiplier. - `resolveFile?: VAVMeshFileResolver`: Manifest-relative path resolver used by direct construction. ### VAVNumericalTrack Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVNumericalTrack. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVNumericalTrack } from "three-blocks/experimental/vertex-animation-video"; type VAVNumericalTrack = VAVNumericalTrackImplementation ``` **Purpose:** Exact UTSBM numerical track — one block-indexed meshopt asset per track, fetched once and streamed progressively. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVNumericalTrack. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVTrackDecoderManifest Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVTrackDecoderManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVTrackDecoderManifest } from "three-blocks/experimental/vertex-animation-video"; type VAVTrackDecoderManifest = AFManifest ``` **Purpose:** Media-decoder manifest assembled over a progressive VAV visual track buffer. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVTrackDecoderManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVTrackDescriptor Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVTrackDescriptor. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVTrackDescriptor } from "three-blocks/experimental/vertex-animation-video"; type VAVTrackDescriptor = VAVTrackContainerImplementation ``` **Purpose:** Normalized byte-index and codec descriptor shared by VAV media tracks. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVTrackDescriptor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVTrackFetch Kind: type; canonical: https://threejs-blocks.com/docs/api/VAVTrackFetch. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVTrackFetch } from "three-blocks/experimental/vertex-animation-video"; type VAVTrackFetch = (input: string, init?: RequestInit) => PromiseLike ``` **Purpose:** Injectable network function used to stream one VAV media track. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVTrackFetch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAVTrackFetchResponse Kind: interface; canonical: https://threejs-blocks.com/docs/api/VAVTrackFetchResponse. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVTrackFetchResponse } from "three-blocks/experimental/vertex-animation-video"; interface VAVTrackFetchResponse ``` **Purpose:** Minimal streaming response consumed by a VAV track. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVTrackFetchResponse. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `arrayBuffer?: () => Promise`: Whole-file fallback for runtimes without a readable streaming body. - `readonly body?: ReadableStream | null`: Optional progressive response body. - `readonly headers?: {get(name: string): string | null;}`: Optional HTTP headers used to validate resumed range responses. - `readonly ok: boolean`: Whether the response completed with a successful HTTP status. - `readonly status: number`: Numeric HTTP status used in stream failures. ### VAVTrackStream Kind: variable; canonical: https://threejs-blocks.com/docs/api/VAVTrackStream. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { VAVTrackStream } from "three-blocks/experimental/vertex-animation-video"; const VAVTrackStream: VAVTrackStreamConstructor ``` **Purpose:** Progressive runtime stream for one VAV media track. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, resume, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `availableFrames(): number`: Number of contiguous decodable frames available from the start of the clip. - `bufferedSecondsAhead(fromFrame: number, frameRate: number): number`: Buffered playback duration ahead of a caller-supplied frame index. - `new (url: string, track: VAVTrackDescriptor, options?: VAVTrackStreamOptions): VAVTrackStream` - `dispose(): void`: Abort the fetch and settle availability waiters. Idempotent; no new bytes arrive afterward. - `readonly done: Promise`: Resolves after the full track arrives and rejects on network/truncation failure. - `frameAvailable(index: number): boolean`: Whether one frame's complete encoded byte range has arrived. - `readonly manifest: VAVTrackDecoderManifest`: Pre-parsed manifest whose frame data views reference this stream's owned buffer. - `readonly receivedBytes: number`: Number of response bytes received so far. - `resume(): Promise`: Continue fetching from the retained prefix. - `suspend(): void`: Abort the active request while retaining the received byte prefix and manifest views. - `readonly totalBytes: number`: Expected byte length declared by the track. - `readonly track: VAVTrackDescriptor`: Normalized track byte-index and codec descriptor. - `readonly url: string`: Resolved track URL supplied at construction. - `whenFrameAvailable(index: number): Promise`: Resolve when a frame becomes decodable; rejects for invalid indices or disposed streams. ### VAVTrackStreamOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VAVTrackStreamOptions. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import type { VAVTrackStreamOptions } from "three-blocks/experimental/vertex-animation-video"; interface VAVTrackStreamOptions ``` **Purpose:** Options for progressively fetching one VAV track. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAVTrackStreamOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. - `fetchImpl?: VAVTrackFetch`: Optional streaming fetch implementation. - `frameRate?: number`: Clip frame rate used to derive decoder timestamps. ### VAV_MANIFEST_TYPE Kind: variable; canonical: https://threejs-blocks.com/docs/api/VAV_MANIFEST_TYPE. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { VAV_MANIFEST_TYPE } from "three-blocks/experimental/vertex-animation-video"; const VAV_MANIFEST_TYPE: "utsubo-vav" ``` **Purpose:** Persisted Vertex Animation Video package discriminator. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAV_MANIFEST_TYPE. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### VAV_MANIFEST_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/VAV_MANIFEST_VERSION. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { VAV_MANIFEST_VERSION } from "three-blocks/experimental/vertex-animation-video"; const VAV_MANIFEST_VERSION: 2 ``` **Purpose:** Second public Vertex Animation Video manifest schema: numerical tracks travel as one block-indexed UTSBM `.utsbm` asset per track, fetched once and streamed progressively. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VAV_MANIFEST_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### ViewportState Kind: interface; canonical: https://threejs-blocks.com/docs/api/ViewportState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { ViewportState } from "three-blocks/app"; interface ViewportState ``` **Purpose:** Declares ViewportState as a public interface. It is exported from three-blocks/app. Its declared surface covers dpr, height, and width. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for ViewportState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly dpr: number` - `readonly height: number` - `readonly width: number` ### VisibilityState Kind: interface; canonical: https://threejs-blocks.com/docs/api/VisibilityState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { VisibilityState } from "three-blocks/app"; interface VisibilityState ``` **Purpose:** Declares VisibilityState as a public interface. It is exported from three-blocks/app. Its declared surface covers visible. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VisibilityState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly visible: boolean` ### VolumeSmokeNodeMaterial Kind: variable; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { VolumeSmokeNodeMaterial } from "three-blocks/smoke"; const VolumeSmokeNodeMaterial: VolumeSmokeNodeMaterialConstructor ``` **Purpose:** Three.js node-material facade for raymarching a SmokeVolume. All input textures and scene nodes are borrowed; the material owns only its generated shader graph and renderer-side material state. Synchronize volume textures after the solver swaps or rebuilds them, render only after the simulation and cache refresh complete, and call inherited `dispose()` before disposing the volume. Missing textures required by an enabled shader variant throw. Runtime-identical constructor for the narrow stable smoke-material facade. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. - `new (options: VolumeSmokeNodeMaterialOptions): VolumeSmokeNodeMaterial`: Create a volume material for a smoke simulation and optional texture bindings. - `setMacrocellSkipping(enabled: boolean, occupancyGridSize?: Vector3 | null): this`: Toggle occupancy skipping and optionally update the occupancy-grid dimensions. - `setOutputMode(outputMode: VolumeSmokeOutputMode): this`: Select safe premultiplied output or unclamped HDR accumulation. - `setSceneDepthNode(sceneDepthNode: Node | null): this`: Replace the borrowed scene-depth node used for opaque intersections. - `setShaderVariants(options?: VolumeSmokeShaderOptions): this`: Rebuild compile-time shader variants; required textures are validated. - `setVolumeTextures(options?: VolumeSmokeTextureOptions): void`: Replace borrowed texture nodes; active shader variants validate dependencies. - `syncVolumeTextures(options?: VolumeSmokeTextureSyncOptions): this`: Synchronize raw texture values without rebuilding the material graph. - `useSmokeOutput(): this`: Restore this material's generated premultiplied smoke output node. ### VolumeSmokeNodeMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeNodeMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeNodeMaterialOptions } from "three-blocks/smoke"; interface VolumeSmokeNodeMaterialOptions ``` **Purpose:** Construction controls for the stable smoke node material. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeNodeMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `absorption?: number | undefined`: Beer-Lambert absorption coefficient. - `anisotropy?: number | undefined`: Henyey-Greenstein forward anisotropy. - `baseColor?: import('three/webgpu').Color | undefined`: Base smoke color. - `curlTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed curl texture required when flow detail is enabled. - `densityBoost?: number | undefined`: Density-to-opacity multiplier. - `densityTexture: VolumeSmokeTextureInput`: Required borrowed density and temperature texture. - `detailNoiseScale?: number | undefined`: Procedural detail spatial frequency. - `detailNoiseStrength?: number | undefined`: Procedural detail amplitude. - `detailTime?: number | undefined`: Procedural detail animation time. - `divergenceTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed divergence texture required for diagnostic lighting. - `dyeTexelSize?: Vector3 | undefined`: Density-grid texel dimensions used for finite differences. - `fireColor?: import('three/webgpu').Color | undefined`: Low-temperature fire color. - `fireColorHot?: import('three/webgpu').Color | undefined`: High-temperature fire color. - `fireIntensity?: number | undefined`: Emissive fire intensity; zero disables emission. - `groundColor?: import('three/webgpu').Color | undefined`: Lower-hemisphere ambient color. - `lightColor?: import('three/webgpu').Color | undefined`: Primary directional-light color. - `lightDir?: Vector3 | undefined`: World-space direction toward the primary light. - `lightOpticalDepthTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed cached-light texture. - `occupancyGridSize?: Vector3 | undefined`: Occupancy-grid dimensions used for macrocell traversal. - `occupancyTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed occupancy texture required for macrocell skipping. - `occupancyThreshold?: number | undefined`: Density threshold below which an occupancy cell is skipped. - `outputMode?: VolumeSmokeOutputMode | undefined`: Premultiplied-alpha output policy. - `pressureTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed pressure texture required for diagnostic lighting. - `sceneDepthNode?: Node | null | undefined`: Borrowed scene-depth node used to stop rays at opaque geometry. - `shadowIntensity?: number | undefined`: Strength of volume self-shadowing. - `shadowSteps?: number | undefined`: Shadow-ray sample count. - `skyColor?: import('three/webgpu').Color | undefined`: Upper-hemisphere ambient color. - `steps?: number | undefined`: Primary raymarch sample count. - `temporalFrame?: number | undefined`: Monotonic frame index used by temporal jitter. - `temporalJitter?: number | undefined`: Temporal ray offset in normalized step units. - `useDiagnosticLighting?: boolean | undefined`: Enable pressure and divergence diagnostic lighting. - `useFlowDetail?: boolean | undefined`: Enable velocity and curl detail; the matching textures become required. - `useHighFrequencyDetail?: boolean | undefined`: Enable procedural high-frequency density detail. - `useMacrocellSkipping?: boolean | undefined`: Enable occupancy-guided empty-space skipping. - `velocityTexture?: VolumeSmokeTextureInput | null | undefined`: Borrowed velocity texture required when flow detail is enabled. ### VolumeSmokeOutputMode Kind: type; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeOutputMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeOutputMode } from "three-blocks/smoke"; type VolumeSmokeOutputMode = 'safe-premultiplied' | 'unclamped-hdr' ``` **Purpose:** Premultiplied-alpha policy used by the smoke material. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeOutputMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### VolumeSmokeRenderCompositor Kind: class; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeRenderCompositor. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { VolumeSmokeRenderCompositor } from "three-blocks/smoke"; class VolumeSmokeRenderCompositor ``` **Purpose:** Scaled HDR rendering, depth-aware reconstruction, and guarded temporal accumulation for smoke volumes. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, render, resize, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. - `readonly colorNode: TSLVec4Node`: Full-resolution resolved premultiplied color for linear post-graph composition. - `composite(): void`: Composite the latest resolved texture into the renderer's active target. - `constructor(renderer: THREE.Renderer, options?: VolumeSmokeRenderCompositorOptions)`: Create a compositor that owns scaled, resolved, and optional history targets. - `depthSigma: number`: Depth difference scale used by bilateral reconstruction. - `dispose(): void`: Dispose all compositor-owned targets and node materials. - `fullHeight: number`: Full drawing-buffer height in pixels. - `fullWidth: number`: Full drawing-buffer width in pixels. - `getTextureNode(): TSLVec4Node`: Returns the full-resolution resolved smoke color texture node. - `height: number`: Height of the scaled smoke target in pixels. - `readonly historyRejection: number`: Difference threshold used to reject stale history. - `readonly historyWeight: number`: Maximum weight retained from valid reprojected history. - `readonly outputMode: VolumeSmokeOutputMode`: Output range and alpha contract used by the resolved texture. - `render(renderScaled: VolumeSmokeScaledRenderCallback, {depthTexture, motionTexture, resetHistory, composite,}?: VolumeSmokeRenderOptions): VolumeSmokeRenderContext`: Render smoke and optional opaque depth into the scaled target, then reconstruct and composite it. The renderer's previous target is restored if either scaled rendering or full-resolution resolve throws. - `readonly renderer: THREE.Renderer`: Borrowed renderer; never disposed by the compositor. - `resetHistory(): this`: Invalidate temporal history before the next render. - `resize(): this`: Resize owned targets from the renderer's current drawing-buffer dimensions. - `scale: number`: Fraction of full drawing-buffer resolution used by the smoke pass. - `setDepthSigma(depthSigma: number): this`: Set the bilateral depth-rejection scale. - `setDepthTexture(depthTexture: THREE.Texture | null | undefined): this`: Bind a borrowed full-resolution depth texture, or restore scaled depth. - `setMotionTexture(motionTexture: THREE.Texture | null | undefined): this`: Bind the borrowed motion texture required by temporal reconstruction. - `setScale(scale: number): this`: Set the scaled-rendering ratio and resize owned targets. - `readonly target: THREE.RenderTarget`: Compositor-owned scaled color/depth target. - `readonly temporal: boolean`: Whether motion-reprojected temporal accumulation is enabled. - `readonly upsampling: VolumeSmokeUpsampling`: Reconstruction filter used when expanding the scaled smoke texture. - `width: number`: Width of the scaled smoke target in pixels. ### VolumeSmokeShaderOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeShaderOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeShaderOptions } from "three-blocks/smoke"; interface VolumeSmokeShaderOptions ``` **Purpose:** Compile-time smoke shader variants rebuilt together. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeShaderOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `outputMode?: VolumeSmokeOutputMode | undefined`: Premultiplied-alpha output policy. - `useDiagnosticLighting?: boolean | undefined`: Enable pressure and divergence diagnostic lighting. - `useFlowDetail?: boolean | undefined`: Enable velocity and curl flow detail. - `useHighFrequencyDetail?: boolean | undefined`: Enable procedural high-frequency density detail. - `useMacrocellSkipping?: boolean | undefined`: Enable occupancy-guided empty-space skipping. ### VolumeSmokeTextureInput Kind: type; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeTextureInput. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeTextureInput } from "three-blocks/smoke"; type VolumeSmokeTextureInput = Texture | Node ``` **Purpose:** Borrowed texture or TSL node accepted as a smoke-volume texture input. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeTextureInput. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. ### VolumeSmokeTextureOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeTextureOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeTextureOptions } from "three-blocks/smoke"; interface VolumeSmokeTextureOptions ``` **Purpose:** Borrowed texture replacements for an existing smoke material. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeTextureOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `curlTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement curl texture. - `densityTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement density texture; `null` is invalid while rendering. - `divergenceTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement divergence texture. - `lightOpticalDepthTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement cached light optical-depth texture. - `occupancyTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement occupancy texture. - `pressureTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement pressure texture. - `velocityTexture?: VolumeSmokeTextureInput | null | undefined`: Replacement velocity texture. ### VolumeSmokeTextureSyncOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/VolumeSmokeTextureSyncOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { VolumeSmokeTextureSyncOptions } from "three-blocks/smoke"; interface VolumeSmokeTextureSyncOptions ``` **Purpose:** Raw borrowed texture values synchronized into existing material nodes. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for VolumeSmokeTextureSyncOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: none recorded. - `curlTexture?: Texture | null | undefined`: Current solver-owned curl texture. - `densityTexture?: Texture | null | undefined`: Current solver-owned density texture. - `divergenceTexture?: Texture | null | undefined`: Current solver-owned divergence texture. - `lightOpticalDepthTexture?: Texture | null | undefined`: Current solver-owned cached light texture. - `occupancyTexture?: Texture | null | undefined`: Current solver-owned occupancy texture. - `pressureTexture?: Texture | null | undefined`: Current solver-owned pressure texture. - `velocityTexture?: Texture | null | undefined`: Current solver-owned velocity texture. ### WATER_RAYMARCH_QUALITY_PRESETS Kind: variable; canonical: https://threejs-blocks.com/docs/api/WATER_RAYMARCH_QUALITY_PRESETS. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WATER_RAYMARCH_QUALITY_PRESETS } from "three-blocks/water"; const WATER_RAYMARCH_QUALITY_PRESETS: Readonly<{performance: Readonly<{resolutionScale: 0.5; whitewaterScale: 0.1875; stepScale: 1.5; isoScale: 1; maxThickness: 4; resolveDepthRange: 1; maxSteps: 224; refinementSteps: 3; normalSmoothing: 0; normalFilterRadius: 0; trilinearTracing: false; scatterSamples: 0; wavesReflectionSteps: 0; temporal: false;}>; balanced: Readonly<{resolutionScale: 0.7; whitewaterScale: 0.25; stepScale: 1; isoScale: 1; maxThickness: 4; resolveDepthRange: 0.75; maxSteps: 384; refinementSteps: 5; normalSmoothing: 0; normalFilterRadius: 0; trilinearTracing: false; scatterSamples: 4; wavesReflectionSteps: 0; temporal: true;}>; high: Readonly<{resolutionScale: 0.9; whitewaterScale: 0.375; stepScale: 1; isoScale: 1; maxThickness: 4; resolveDepthRange: 0.5; maxSteps: 384; refinementSteps: 6; normalSmoothing: 1.5; normalFilterRadius: 2; trilinearTracing: false; scatterSamples: 8; wavesReflectionSteps: 0; temporal: true;}>; cinematic: Readonly<{resolutionScale: 1; whitewaterScale: 0.5; stepScale: 1; isoScale: 1; maxThickness: 4; resolveDepthRange: 0.35; maxSteps: 448; refinementSteps: 7; normalSmoothing: 3.5; normalFilterRadius: 5; trilinearTracing: true; scatterSamples: 8; wavesReflectionSteps: 24; temporal: false;}>; extreme: Readonly<{resolutionScale: 1; whitewaterScale: 1; stepScale: 1; isoScale: 1; maxThickness: 4; resolveDepthRange: 0.25; maxSteps: 512; refinementSteps: 8; normalSmoothing: 4.5; normalFilterRadius: 5; trilinearTracing: true; scatterSamples: 12; wavesReflectionSteps: 32; temporal: false;}>;}> ``` **Purpose:** Coherent raymarch quality tiers. The settings are intentionally grouped: increasing only the loop cap does not improve a trace that is still running below native resolution with nearest-cell normals. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WATER_RAYMARCH_QUALITY_PRESETS. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. ### WORKER_PROTOCOL_VERSION Kind: variable; canonical: https://threejs-blocks.com/docs/api/WORKER_PROTOCOL_VERSION. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WORKER_PROTOCOL_VERSION } from "three-blocks/worker"; const WORKER_PROTOCOL_VERSION: 1 ``` **Purpose:** Typed, explicit main/worker transport with state, event, and RPC lanes. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WORKER_PROTOCOL_VERSION. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WaterCaustics Kind: class; canonical: https://threejs-blocks.com/docs/api/WaterCaustics. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WaterCaustics } from "three-blocks/water"; class WaterCaustics ``` **Purpose:** Simulation-driven sun caustics and column transmittance for a WaterVolume. A displaced SurfaceField grid conserves source-cell energy while refracting it onto the floor plane; a small temporal resolve settles triangle shimmer. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. - `chromatic: boolean`: Whether sampling applies a small wavelength-dependent offset. - `constructor(water: WaterVolume, {resolution, intensity, chromatic, temporal,}?: WaterCausticsOptions)`: Create simulation-driven caustics for a texture-backed water surface. - `dispose(): void`: Dispose all caustics render targets, geometry, and materials. - `resetHistory(): this`: Invalidate temporal caustics history before the next update. - `resolution: number`: Width and height of the square caustics targets. - `sample(worldPosition: TSLVec3Node): TSLVec3Node`: Sample RGB caustic irradiance at a world-space receiver position. - `sampleShadow(worldPosition: TSLVec3Node): TSLFloatNode`: Sample column sun transmittance at a world-space receiver position. - `get texture(): THREE.Texture`: Latest resolved caustics and sun-transmittance texture. - `get textureNode(): TSLTextureNode`: Stable texture node; its backing history texture follows ping-pong swaps. - `uniforms: WaterCausticsUniforms`: Mutable sun, intensity, absorption, and temporal uniforms. - `update(renderer: THREE.Renderer): this`: Render the caustic field after the water step and before the scene pass. - `water: WaterVolume`: Borrowed water simulation that supplies the surface field and transforms. ### WaterFoamMeshOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterFoamMeshOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterFoamMeshOptions } from "three-blocks/water"; interface WaterFoamMeshOptions ``` **Purpose:** Display controls for the free diffuse-whitewater sprite mesh. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterFoamMeshOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `baseSize?: number | undefined`: Base world-space particle size. - `displayFraction?: number | undefined`: Fraction of the live whitewater population displayed. - `maxPixelSize?: number | undefined`: Maximum rendered particle diameter in pixels. - `minPixelSize?: number | undefined`: Minimum rendered particle diameter in pixels. - `sunDirection?: Vector3 | undefined`: World-space sun direction used for sprite lighting. ### WaterFoamOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterFoamOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterFoamOptions } from "three-blocks/water"; interface WaterFoamOptions ``` **Purpose:** Diffuse whitewater simulation controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterFoamOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `bubbleBuoyancy?: number | undefined`: Upward acceleration applied to submerged bubbles. - `bubbleDrag?: number | undefined`: Drag applied to submerged bubbles. - `capacity?: number | undefined`: Maximum number of live diffuse particles. - `crestStrength?: number | undefined`: Relative contribution from surface crests. - `foamDepositRate?: number | undefined`: Fraction of diffuse particles deposited into the surface foam field. - `seed?: number | undefined`: Deterministic random seed. - `spawnRate?: number | undefined`: Diffuse particles spawned per eligible fluid particle. - `sprayDrag?: number | undefined`: Drag applied to airborne spray. - `trappedAirStrength?: number | undefined`: Relative contribution from trapped-air motion. ### WaterMaterialSSROptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterMaterialSSROptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterMaterialSSROptions } from "three-blocks/water"; interface WaterMaterialSSROptions ``` **Purpose:** Screen-space reflection controls for the water composite. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterMaterialSSROptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `maxDistance?: number | undefined`: Maximum reflection distance in view units. - `refine?: number | undefined`: Binary refinement steps after an intersection. - `steps?: number | undefined`: Coarse reflection-march steps. - `thickness?: number | undefined`: Accepted depth separation at an intersection. ### WaterMaterialUniformOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterMaterialUniformOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterMaterialUniformOptions } from "three-blocks/water"; interface WaterMaterialUniformOptions ``` **Purpose:** Curated initial appearance controls for WaterNodeMaterial. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterMaterialUniformOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `absorption?: Vector3 | undefined`: Per-channel absorption coefficients. - `baseRoughness?: number | undefined`: Base water-surface roughness. - `dispersionStrength?: number | undefined`: Chromatic dispersion strength. - `foamColor?: Color | undefined`: Foam albedo color. - `foamOpacity?: number | undefined`: Foam opacity. - `foamThreshold?: number | undefined`: Foam-coverage threshold. - `glitterStrength?: number | undefined`: Procedural specular-glitter intensity. - `refractionStrength?: number | undefined`: Refraction displacement strength. - `scatterColor?: Color | undefined`: In-scattered light color. - `scatterDepth?: number | undefined`: Depth over which in-scattering approaches its maximum. - `sssStrength?: number | undefined`: Subsurface-scattering strength. - `sunColor?: Color | undefined`: Sun-light color. - `sunDirection?: Vector3 | undefined`: World-space sun direction. - `sunStrength?: number | undefined`: Direct-sun intensity. - `thicknessMax?: number | undefined`: Maximum resolved optical thickness. ### WaterNodeMaterial Kind: variable; canonical: https://threejs-blocks.com/docs/api/WaterNodeMaterial. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WaterNodeMaterial } from "three-blocks/water"; const WaterNodeMaterial: WaterNodeMaterialConstructor ``` **Purpose:** Three.js node-material facade for compositing either public water surface renderer. The material borrows scene nodes, environment textures, and the renderer output; it owns only its generated graph and material renderer state. Construct it after the surface renderer, update that renderer before drawing, and call inherited `dispose()` before disposing the surface renderer. Missing scene color or depth nodes throw during construction. Runtime-identical constructor for the narrow stable water-material facade. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `new (surface: WaterSurfaceRenderer | WaterRayMarchRenderer, options: WaterNodeMaterialOptions): WaterNodeMaterial`: Create the water material for a surface or raymarch renderer. ### WaterNodeMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterNodeMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterNodeMaterialOptions } from "three-blocks/water"; interface WaterNodeMaterialOptions ``` **Purpose:** Construction inputs for the fullscreen stable water composite. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterNodeMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `compositeWhitewater?: boolean | undefined`: Resolve the renderer's separate whitewater accumulation target. - `contactFoam?: number | undefined`: World-space width of contact foam; zero disables it. - `dispersion?: number | undefined`: Initial chromatic dispersion strength. - `envNode?: Texture | Node | null | undefined`: Borrowed environment texture or already-built environment node. - `glitter?: number | undefined`: Initial procedural glitter strength. - `physicalRefraction?: boolean | undefined`: Enable physical screen-space refraction. - `reducedMotion?: boolean | undefined`: Suppress motion-heavy glitter and temporal effects. - `sceneColorNode: Node`: Borrowed scene-color texture node sampled behind the water. - `sceneDepthNode: Node`: Borrowed scene-depth texture node used for intersections and refraction. - `ssr?: WaterMaterialSSROptions | boolean | undefined`: Enable reflections with defaults, provide overrides, or disable them. - `underwater?: boolean | undefined`: Use the underwater composite branch. - `uniforms?: WaterMaterialUniformOptions | undefined`: Curated initial appearance values copied into material-owned uniforms. ### WaterPreset Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterPreset } from "three-blocks/water"; type WaterPreset = 'pool' | 'calm' | 'ocean-swell' | 'storm' ``` **Purpose:** Calibrated starting profile for the stable water block. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WaterRayMarchQualityOverrides Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchQualityOverrides. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchQualityOverrides } from "three-blocks/water"; interface WaterRayMarchQualityOverrides ``` **Purpose:** Optional overrides applied over a named raymarch quality tier. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchQualityOverrides. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `isoScale?: number | undefined`: Override surface-density threshold scale. - `maxSteps?: number | undefined`: Override raymarch step cap. - `maxThickness?: number | undefined`: Override maximum accumulated thickness. - `normalFilterRadius?: number | undefined`: Override normal-filter radius. - `normalSmoothing?: number | undefined`: Override normal smoothing. - `refinementSteps?: number | undefined`: Override binary surface refinements. - `resolutionScale?: number | undefined`: Override trace-target scale. - `resolveDepthRange?: number | undefined`: Override edge-aware resolve range. - `scatterSamples?: WaterRayMarchScatterSamples | undefined`: Override volumetric scattering samples. - `stepScale?: number | undefined`: Override grid traversal step scale. - `temporal?: boolean | undefined`: Override temporal accumulation. - `trilinearTracing?: boolean | undefined`: Override continuous trilinear density sampling. - `wavesReflectionSteps?: WaterRayMarchReflectionSteps | undefined`: Override analytic wave-reflection steps. - `whitewaterScale?: number | undefined`: Override whitewater-target scale. ### WaterRayMarchQualityPreset Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchQualityPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchQualityPreset } from "three-blocks/water"; type WaterRayMarchQualityPreset = 'performance' | 'balanced' | 'high' | 'cinematic' | 'extreme' ``` **Purpose:** Named coherent quality tier for grid raymarching. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchQualityPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WaterRayMarchQualitySettings Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchQualitySettings. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchQualitySettings } from "three-blocks/water"; interface WaterRayMarchQualitySettings ``` **Purpose:** Complete read-only quality snapshot for grid raymarching. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchQualitySettings. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `readonly isoScale: number`: Density threshold multiplier used to resolve the surface. - `readonly maxSteps: number`: Hard cap on raymarch steps. - `readonly maxThickness: number`: Maximum accumulated fluid thickness in grid units. - `readonly normalFilterRadius: number`: Edge-aware normal-filter radius. - `readonly normalSmoothing: number`: Normal-field smoothing strength. - `readonly refinementSteps: number`: Binary surface-refinement steps. - `readonly resolutionScale: number`: Trace-target scale relative to the drawing buffer. - `readonly resolveDepthRange: number`: Edge-aware resolve depth range. - `readonly scatterSamples: WaterRayMarchScatterSamples`: Volumetric scattering sample count. - `readonly stepScale: number`: Distance multiplier for each grid traversal step. - `readonly temporal: boolean`: Enable temporal surface accumulation. - `readonly trilinearTracing: boolean`: Sample the continuous trilinear density field. - `readonly wavesReflectionSteps: WaterRayMarchReflectionSteps`: Analytic wave-reflection march length. - `readonly whitewaterScale: number`: Whitewater-target scale relative to the drawing buffer. ### WaterRayMarchQualitySnapshot Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchQualitySnapshot. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchQualitySnapshot } from "three-blocks/water"; interface WaterRayMarchQualitySnapshot extends WaterRayMarchQualitySettings ``` **Purpose:** Named quality snapshot returned by WaterRayMarchRenderer.getQualitySettings. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchQualitySnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `readonly qualityPreset: WaterRayMarchQualityPreset`: Named tier over which explicit overrides were applied. ### WaterRayMarchReflectionSteps Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchReflectionSteps. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchReflectionSteps } from "three-blocks/water"; type WaterRayMarchReflectionSteps = 0 | 24 | 32 ``` **Purpose:** Supported analytic wave-reflection march lengths. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchReflectionSteps. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WaterRayMarchRenderer Kind: variable; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchRenderer. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WaterRayMarchRenderer } from "three-blocks/water"; const WaterRayMarchRenderer: WaterRayMarchRendererConstructor ``` **Purpose:** Grid-raymarched surface renderer for a seeded WaterVolume. It owns its trace, resolve, temporal, and whitewater targets plus an optional grid-mirror texture; the renderer, volume, camera, and whitewater mesh remain caller-owned. Call the water step first, then WaterRayMarchRenderer.update, then draw the water material. Unknown quality tiers, incompatible solver configuration, and use after teardown throw. Dispose the material first; renderer disposal is safe to repeat. Runtime-identical constructor for the narrow grid-raymarched water facade. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, resize, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. - `new (renderer: Renderer, water: WaterVolume, options?: WaterRayMarchRendererOptions): WaterRayMarchRenderer`: Create a raymarched renderer for a water simulation. - `dispose(): void`: Release owned targets, materials, and grid-mirror resources; safe to repeat. - `getQualitySettings(): Readonly`: Return a detached, read-only snapshot of the current quality configuration. - `readonly qualityPreset: WaterRayMarchQualityPreset`: Named quality tier beneath the current explicit overrides. - `resetHistory(): this`: Invalidate temporal history after camera cuts or discontinuous source changes. - `resize(): this`: Resize owned targets to the renderer drawing buffer. - `readonly resolutionScale: number`: Current trace-target scale. - `setQualityPreset(name: WaterRayMarchQualityPreset | string, overrides?: WaterRayMarchQualityOverrides): this`: Apply a coherent quality tier followed by explicit overrides. - `setResolutionScale(scale: number): this`: Change trace resolution and resize owned targets. - `setTraceOptions(options?: WaterRayMarchTraceOptions): this`: Change trace-loop and temporal choices without replacing the named tier. - `setWhitewaterMesh(mesh: Object3D | null | undefined): this`: Attach or clear a caller-owned whitewater mesh used during accumulation. - `setWhitewaterScale(scale: number): this`: Change whitewater resolution and resize the owned accumulation target. - `update(renderer: Renderer, camera: WaterSurfaceCamera): this`: Raymarch water after simulation and before drawing the composite material. - `readonly whitewaterScale: number`: Current whitewater-target scale. ### WaterRayMarchRendererOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchRendererOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchRendererOptions } from "three-blocks/water"; interface WaterRayMarchRendererOptions extends WaterRayMarchQualityOverrides ``` **Purpose:** Construction controls for the grid-raymarched water surface. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchRendererOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `qualityPreset?: WaterRayMarchQualityPreset | string | undefined`: Named coherent starting tier. - `textureGridMirror?: boolean | undefined`: Mirror packed render data into a filterable 3D texture. ### WaterRayMarchScatterSamples Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchScatterSamples. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchScatterSamples } from "three-blocks/water"; type WaterRayMarchScatterSamples = 0 | 4 | 8 | 12 ``` **Purpose:** Supported volumetric scattering sample counts. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchScatterSamples. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WaterRayMarchTraceOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterRayMarchTraceOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterRayMarchTraceOptions } from "three-blocks/water"; interface WaterRayMarchTraceOptions ``` **Purpose:** Trace-only options that can change without selecting a new quality tier. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterRayMarchTraceOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `maxSteps?: number | undefined`: Hard cap on raymarch steps. - `normalFilterRadius?: number | undefined`: Edge-aware normal-filter radius. - `normalSmoothing?: number | undefined`: Normal-field smoothing strength. - `refinementSteps?: number | undefined`: Binary surface-refinement steps. - `scatterSamples?: WaterRayMarchScatterSamples | undefined`: Volumetric scattering sample count. - `temporal?: boolean | undefined`: Enable temporal surface accumulation. - `trilinearTracing?: boolean | undefined`: Sample the continuous trilinear density field. - `wavesReflectionSteps?: WaterRayMarchReflectionSteps | undefined`: Analytic wave-reflection march length. ### WaterSurfaceCamera Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterSurfaceCamera. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterSurfaceCamera } from "three-blocks/water"; interface WaterSurfaceCamera extends Camera ``` **Purpose:** Perspective camera contract used by both water surface renderers. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterSurfaceCamera. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `far: number`: Far clipping plane greater than WaterSurfaceCamera.near. - `near: number`: Positive near clipping plane. ### WaterSurfaceFieldOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterSurfaceFieldOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterSurfaceFieldOptions } from "three-blocks/water"; interface WaterSurfaceFieldOptions ``` **Purpose:** Top-down surface-field and height-probe controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterSurfaceFieldOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `foamDecay?: number | undefined`: Per-step foam-coverage decay. - `foamGain?: number | undefined`: Foam deposition gain. - `foamSpeedThreshold?: number | undefined`: Minimum particle speed contributing to foam. - `isoMass?: number | undefined`: Density threshold treated as the fluid surface. - `probeCapacity?: number | undefined`: Maximum number of concurrent height probes. - `texture?: boolean | undefined`: Maintain a sampleable surface-field texture. ### WaterSurfaceFoamMeshOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterSurfaceFoamMeshOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterSurfaceFoamMeshOptions } from "three-blocks/water"; interface WaterSurfaceFoamMeshOptions ``` **Purpose:** Display controls for the surface-deposited foam sprite mesh. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterSurfaceFoamMeshOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `aging?: boolean | undefined`: Enable age-dependent foam appearance. - `baseSize?: number | undefined`: Base world-space splat size. - `coverageFeather?: number | undefined`: Feather width around the coverage threshold. - `coverageThreshold?: number | undefined`: Foam coverage below which splats are rejected. - `displayFraction?: number | undefined`: Fraction of eligible surface splats displayed. - `jitter?: number | undefined`: Stable position-jitter amplitude within a surface cell. - `maxPixelSize?: number | undefined`: Maximum rendered splat diameter in pixels. - `minPixelSize?: number | undefined`: Minimum rendered splat diameter in pixels. - `splatsPerColumn?: number | undefined`: Candidate foam splats emitted per surface-field column. ### WaterSurfaceRenderer Kind: variable; canonical: https://threejs-blocks.com/docs/api/WaterSurfaceRenderer. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WaterSurfaceRenderer } from "three-blocks/water"; const WaterSurfaceRenderer: WaterSurfaceRendererConstructor ``` **Purpose:** Screen-space surface reconstruction facade for a seeded WaterVolume. It owns all render targets, helper materials, and particle-splat geometry; the renderer, volume, camera, and optional whitewater mesh remain caller-owned. Call the volume step first, then WaterSurfaceRenderer.update, then draw the water material. Invalid dimensions and use after teardown throw. Dispose the water material first; this renderer's disposal is safe to repeat. Runtime-identical constructor for the narrow screen-space water-renderer facade. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, update, resize, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `new (renderer: Renderer, source: WaterVolume, options?: WaterSurfaceRendererOptions): WaterSurfaceRenderer`: Create a mesh-surface renderer for a water simulation. - `readonly count: number`: Active particle count used by the next reconstruction update. - `dispose(): void`: Release renderer-owned targets, helper materials, and geometry; safe to repeat. - `readonly fullHeight: number`: Full drawing-buffer height after the most recent resize. - `readonly fullWidth: number`: Full drawing-buffer width after the most recent resize. - `readonly height: number`: Reconstruction-target height after the most recent resize. - `resetHistory(): this`: Invalidate temporal history after camera cuts or discontinuous source changes. - `resize(): this`: Resize owned targets to the renderer drawing buffer. - `setCount(count: number): this`: Change the active particle count, bounded by the source capacity. - `setWhitewaterMesh(mesh: Object3D | null | undefined): this`: Attach or clear a caller-owned whitewater mesh used during accumulation. - `setWorldRadius(radius: number): this`: Change the world-space splat radius and dependent reconstruction ranges. - `update(renderer: Renderer, camera: WaterSurfaceCamera): this`: Reconstruct water after simulation and before drawing the composite material. - `readonly width: number`: Reconstruction-target width after the most recent resize. ### WaterSurfaceRendererOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterSurfaceRendererOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterSurfaceRendererOptions } from "three-blocks/water"; interface WaterSurfaceRendererOptions ``` **Purpose:** Construction controls for screen-space fluid surface reconstruction. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterSurfaceRendererOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `depthRangeFactor?: number | undefined`: Depth discontinuity range as a multiple of particle radius. - `depthSmoothingRadius?: number | undefined`: Final edge-preserving depth smoothing half-width in texels. - `filterIterations?: number | undefined`: Narrow-range horizontal/vertical filter iterations. - `filterRadius?: number | undefined`: Maximum adaptive filter half-width in texels. - `resolutionScale?: number | undefined`: Depth and normal target scale relative to the drawing buffer. - `temporalBlend?: number | undefined`: Local temporal-history weight. - `thicknessBlurRadius?: number | undefined`: Thickness Gaussian blur half-width in texels. - `thicknessFalloff?: number | null | undefined`: Thickness falloff distance, or `null` for the radius-derived default. - `thicknessRadiusScale?: number | undefined`: Thickness splat radius relative to depth splats. - `thicknessRangeFactor?: number | undefined`: Maximum thickness depth as a multiple of particle radius. - `thicknessScale?: number | undefined`: Thickness target scale relative to the drawing buffer. - `thicknessStrength?: number | undefined`: Per-particle optical-thickness contribution. - `whitewaterScale?: number | undefined`: Whitewater target scale relative to the drawing buffer. - `worldRadius?: number | undefined`: Particle splat radius in world units. - `worldSigma?: number | null | undefined`: Gaussian sigma in world units, or `null` for the radius-derived default. ### WaterVolume Kind: variable; canonical: https://threejs-blocks.com/docs/api/WaterVolume. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { WaterVolume } from "three-blocks/water"; const WaterVolume: WaterVolumeConstructor ``` **Purpose:** Stable MLS-MPM water facade. Construct and configure the block, call WaterVolume.seed once, then call WaterVolume.step before any surface renderer update in each frame. The block owns its solver, surface field, and optional foam simulation; the renderer and bound domain object remain caller-owned. Invalid capacities, grids, preset values, or use before seeding/after teardown can throw. Dispose dependent surface renderers first, then call WaterVolume.dispose; disposal is safe to repeat. Runtime-identical constructor for the narrow stable water-volume facade. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor, step, and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_compute, https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. - `addSplash(x: number, y: number, z: number, vx?: number, vy?: number, vz?: number, radius?: number, strength?: number): this`: Queue one bounded world-space splash impulse for the next step. - `bindDomain(object: Object3D, options?: WaterVolumeDomainBindingOptions): this`: Bind the normalized volume to a caller-owned object's world transform. - `readonly capacity: number`: Maximum particle capacity fixed at construction. - `new (options?: WaterVolumeOptions): WaterVolume`: Create a stable particle-water simulation with optional solver controls. - `createFoamMesh(options?: WaterFoamMeshOptions): Object3D`: Create a block-owned diffuse-particle view whose mesh resources the caller disposes. - `createSurfaceFoamMesh(options?: WaterSurfaceFoamMeshOptions): Object3D`: Create a surface-field foam view whose mesh resources the caller disposes. - `dispose(): void`: Release block-owned simulation resources; safe to call repeatedly. - `getHeightAt(worldX: number, worldZ: number): Promise`: Resolve the simulated water height at a world-space X/Z position. - `getLastStepStats(): Readonly`: Return a read-only snapshot of the most recent solver step. - `getStillWaterLevel(): number`: Return the transformed still-water level at the domain center. - `particleCount: number`: Active particle count, bounded by WaterVolume.capacity. - `readonly preset: WaterPreset`: Calibrated preset resolved at construction. - `seed(renderer: Renderer): this`: Seed solver-owned particles before the first step; repeated seeding resets them. - `setDomainTransform(matrixWorld: Matrix4): this`: Copy an explicit world transform into the volume mapping. - `setGravity(magnitude: number): this`: Change the positive world-space gravity magnitude for later steps. - `setPointer(worldPosition: Vector3 | null, strength?: number): this`: Set or clear the world-space pointer force for the next step. - `step(renderer: Renderer, dt: number): this`: Submit one water step before updating dependent surface renderers. - `syncDomainTransform(force?: boolean): this`: Refresh an auto-bound domain after its object transform changes. - `time: number`: Elapsed simulation time; assigning updates subsequent wave evaluation. - `waveEnergy: number`: Runtime energy multiplier for the analytic wave field. ### WaterVolumeBoundaryMode Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterVolumeBoundaryMode. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeBoundaryMode } from "three-blocks/water"; type WaterVolumeBoundaryMode = 'absorbing' | 'reflective' ``` **Purpose:** Horizontal boundary response used by the water volume. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeBoundaryMode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WaterVolumeBoundaryOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeBoundaryOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeBoundaryOptions } from "three-blocks/water"; interface WaterVolumeBoundaryOptions ``` **Purpose:** Domain-boundary response controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeBoundaryOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `floorFriction?: number | undefined`: Tangential velocity retained at the floor. - `margin?: number | undefined`: Grid-cell margin reserved around the simulation domain. - `mode?: WaterVolumeBoundaryMode | undefined`: Horizontal open-water or closed-tank response. - `rimDamping?: number | undefined`: Velocity retained inside the absorbing rim. - `rimWidth?: number | undefined`: Normalized width of the absorbing rim. - `velocityDamping?: number | undefined`: Velocity retained after boundary projection. - `wallPushback?: number | undefined`: Restoring velocity applied near walls. ### WaterVolumeDomainBindingOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeDomainBindingOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeDomainBindingOptions } from "three-blocks/water"; interface WaterVolumeDomainBindingOptions ``` **Purpose:** Domain-object binding controls for WaterVolume. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeDomainBindingOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `autoUpdate?: boolean | undefined`: Re-read the object's world matrix before every solver step. ### WaterVolumeLattice Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeLattice. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeLattice } from "three-blocks/water"; interface WaterVolumeLattice ``` **Purpose:** Explicit particle lattice used during initial seeding. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeLattice. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `x: number`: Particle columns along the local X axis. - `y: number`: Particle layers along the local Y axis. - `z: number`: Particle columns along the local Z axis. ### WaterVolumeMaterialOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeMaterialOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeMaterialOptions } from "three-blocks/water"; interface WaterVolumeMaterialOptions ``` **Purpose:** Fluid material controls resolved after the selected preset. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeMaterialOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `restDensity?: number | undefined`: Rest density; omission derives it from the seed lattice. - `stiffness?: number | undefined`: Pressure stiffness of the fluid model. - `viscosity?: number | undefined`: Velocity-gradient viscosity. ### WaterVolumeOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeOptions } from "three-blocks/water"; interface WaterVolumeOptions ``` **Purpose:** Construction controls for the stable ocean/tank water volume. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `boundary?: WaterVolumeBoundaryOptions | undefined`: Domain-boundary overrides. - `capacity?: number | undefined`: Maximum particle capacity. - `domainSize?: Vector3 | undefined`: World-space dimensions of the bound water domain. - `fillHeight?: number | undefined`: Initial water-column height as a fraction of domain height. - `foam?: WaterFoamOptions | boolean | undefined`: Diffuse-whitewater controls, `true` for defaults, or `false` to disable it. - `gravity?: number | undefined`: Positive world-space gravity magnitude in metres per second squared. - `gridSize?: Vector3 | undefined`: Integer MPM grid resolution. - `material?: WaterVolumeMaterialOptions | undefined`: Fluid material overrides. - `pointer?: WaterVolumePointerOptions | undefined`: Pointer-force overrides. - `preset?: WaterPreset | undefined`: Calibrated starting profile. - `seed?: WaterVolumeSeedOptions | undefined`: Initial particle-layout overrides. - `solver?: WaterVolumeSolverOptions | undefined`: Underlying MPM performance and scheduling overrides. - `splash?: WaterVolumeSplashOptions | undefined`: Splash-emitter pool overrides. - `surfaceField?: WaterSurfaceFieldOptions | boolean | undefined`: Surface-field controls, `true` for defaults, or `false` to disable it. - `waves?: WaterVolumeWavesOptions | null | undefined`: Wave controls, or `null` to disable procedural ocean waves. ### WaterVolumePointerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumePointerOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumePointerOptions } from "three-blocks/water"; interface WaterVolumePointerOptions ``` **Purpose:** World-space pointer-force controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumePointerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `decay?: number | undefined`: Per-step pointer-force decay. - `impulse?: number | undefined`: Horizontal pointer impulse. - `lift?: number | undefined`: Upward impulse mixed into pointer interaction. - `radius?: number | undefined`: World-space pointer influence radius. - `verticalFalloff?: number | undefined`: Vertical attenuation applied away from the water surface. ### WaterVolumeSeedOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeSeedOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeSeedOptions } from "three-blocks/water"; interface WaterVolumeSeedOptions ``` **Purpose:** Initial water-column layout controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeSeedOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `lattice?: WaterVolumeLattice | null | undefined`: Explicit lattice dimensions, or `null` for capacity-derived dimensions. - `profile?: boolean | undefined`: Apply hydrostatic density profiling to the initial column. - `waves?: boolean | undefined`: Include analytic wave displacement in the initial column. ### WaterVolumeSolverOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeSolverOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeSolverOptions } from "three-blocks/water"; interface WaterVolumeSolverOptions ``` **Purpose:** Intentional performance and scheduling controls for the underlying MPM solver. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeSolverOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `densityPrediction?: boolean | undefined`: Enable the density-prediction correction path. - `formulation?: 'fused' | 'reference' | undefined`: Fused production graph or readable reference graph. - `maxVelocity?: number | undefined`: Maximum particle velocity in simulation units per second. - `p2gMode?: 'auto' | 'atomic' | 'subgroup' | undefined`: Grid accumulation strategy. - `packedGridMirror?: boolean | undefined`: Maintain the packed render-facing grid mirror. - `substeps?: number | undefined`: Solver substeps submitted for one host step. - `workgroupSize?: number | undefined`: GPU workgroup width used by particle passes. ### WaterVolumeSplashOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeSplashOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeSplashOptions } from "three-blocks/water"; interface WaterVolumeSplashOptions ``` **Purpose:** Bounded splash-emitter pool controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeSplashOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `slots?: number | undefined`: Number of independently fading splash slots. ### WaterVolumeStepStats Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeStepStats. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeStepStats } from "three-blocks/water"; interface WaterVolumeStepStats ``` **Purpose:** Read-only scheduling and block-state snapshot for the most recent water step. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeStepStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `readonly dispatches: number`: Compute dispatches submitted by the step. - `readonly particleCount: number`: Active particle count. - `readonly preset: WaterPreset`: Calibrated preset active for the water block. - `readonly probeCount: number`: Height probes pending or sampled by the surface field. - `readonly profileBeta: number`: Hydrostatic seed-profile coefficient. - `readonly restDensity: number`: Resolved material rest density. - `readonly submissions: number`: Renderer compute submissions used by the step. - `readonly substeps: number`: Solver substeps submitted for the host delta. ### WaterVolumeWavesOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterVolumeWavesOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterVolumeWavesOptions } from "three-blocks/water"; interface WaterVolumeWavesOptions ``` **Purpose:** Procedural wave and wavemaker controls. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterVolumeWavesOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `components?: readonly WaterWaveComponentOptions[] | undefined`: Explicit wave spectrum; omission uses the ocean-swell spectrum. - `energy?: number | undefined`: Energy multiplier applied to all components. - `nudgeRate?: number | undefined`: Rate at which the wavemaker nudges particles toward the analytic field. - `seedScale?: number | undefined`: Wave displacement scale used while seeding particles. ### WaterWaveComponentOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WaterWaveComponentOptions. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterWaveComponentOptions } from "three-blocks/water"; interface WaterWaveComponentOptions ``` **Purpose:** One dispersive wave component used by the ocean presets. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterWaveComponentOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. - `amplitude?: number | undefined`: Surface displacement amplitude in world units. - `direction?: WaterWaveDirection | undefined`: Horizontal propagation direction. - `kx?: number | undefined`: Explicit X wave-number component. - `kz?: number | undefined`: Explicit Z wave-number component. - `phase?: number | undefined`: Initial phase in radians. - `wavelength?: number | undefined`: Wavelength in world units; used when explicit wave numbers are omitted. ### WaterWaveDirection Kind: type; canonical: https://threejs-blocks.com/docs/api/WaterWaveDirection. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import type { WaterWaveDirection } from "three-blocks/water"; type WaterWaveDirection = readonly [x: number, z: number] | {/** Optional X component of an object-form direction. */ x?: number | undefined; /** Optional Y component retained for Three.js vector compatibility. */ y?: number | undefined; /** Optional Z component of an object-form direction. */ z?: number | undefined;} ``` **Purpose:** Direction accepted by one procedural ocean-wave component. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WaterWaveDirection. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: none recorded. ### WorkerBootState Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerBootState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerBootState } from "three-blocks/app"; interface WorkerBootState ``` **Purpose:** Declares WorkerBootState as a public interface. It is exported from three-blocks/app. Its declared surface covers canvas, page, and shaderCapture. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerBootState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly canvas: TransferableValue` - `readonly page: TransferableValue` - `readonly shaderCapture?: WorkerShaderCaptureActivation`: Development-only shader capture session relayed from the page shell. ### WorkerClient Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerClient. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerClient } from "three-blocks/worker"; class WorkerClient ``` **Purpose:** Main-side transport retaining only latest state across endpoint replacement. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `get connected(): boolean` - `constructor(...arguments_: CloneableContractArguments)` - `dispose(): void` - `get disposed(): boolean` - `readonly events: WorkerEventLane` - `get lastError(): SerializedWorkerError | undefined` - `replaceEndpoint(source: MessageEndpointSource): Promise` - `readonly rpc: WorkerRpcLane` - `readonly state: WorkerStateLane` ### WorkerClientOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerClientOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerClientOptions } from "three-blocks/worker"; interface WorkerClientOptions ``` **Purpose:** Declares WorkerClientOptions as a public interface. It is exported from three-blocks/worker. Its declared surface covers cloneValue, closeEndpointOnDispose, closeEndpointOnReplace, onError, and protocolVersion, plus 2 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerClientOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cloneValue?: CloneValue` - `readonly closeEndpointOnDispose?: boolean` - `readonly closeEndpointOnReplace?: boolean` - `readonly onError?: (error: SerializedWorkerError) => void` - `readonly protocolVersion?: number` - `readonly source?: string` - `readonly validateStructuredClone?: boolean` ### WorkerEventHandlerContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerEventHandlerContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerEventHandlerContext } from "three-blocks/worker"; interface WorkerEventHandlerContext extends WorkerHandlerContext ``` **Purpose:** Declares WorkerEventHandlerContext as a public interface. It is exported from three-blocks/worker. Its declared surface covers lane and sequence. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerEventHandlerContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly lane: 'event'` - `readonly sequence: number` ### WorkerEventHandlers Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerEventHandlers. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerEventHandlers } from "three-blocks/worker"; type WorkerEventHandlers = {[TName in StringKey]?: (value: TEvents[TName], context: WorkerEventHandlerContext) => MaybePromise;} ``` **Purpose:** Declares WorkerEventHandlers as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerEventHandlers. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WorkerEventLane Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerEventLane. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerEventLane } from "three-blocks/worker"; interface WorkerEventLane ``` **Purpose:** Declares WorkerEventLane as a public interface. It is exported from three-blocks/worker. Its declared surface covers emit. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerEventLane. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `emit>(name: TName, value: TEvents[TName], options?: SendOptions): void` ### WorkerHandlerContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerHandlerContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerHandlerContext } from "three-blocks/worker"; interface WorkerHandlerContext ``` **Purpose:** Declares WorkerHandlerContext as a public interface. It is exported from three-blocks/worker. Its declared surface covers key, protocolVersion, and source. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerHandlerContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly key: TName` - `readonly protocolVersion: number` - `readonly source: string` ### WorkerHost Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerHost. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerHost } from "three-blocks/app"; class WorkerHost ``` **Purpose:** Owns worker creation, restart, boot transfer, status, text replay, and smoke state. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `attachStats(stats: StatsMainAdapter): void` - `get canvas(): HTMLCanvasElement` - `get canvasElement(): HTMLCanvasElement`: The rendering canvas this host drives. - `canvasRect(): {readonly width: number; readonly height: number;}`: CSS size of the rendering canvas, which is what the drawing buffer and any DOM-synchronized text must be sized from. It differs from the window whenever a classic scrollbar, page padding, or a non-fullscreen layout gives the canvas a box of its own; sizing from the window instead scales everything the canvas draws against the surrounding DOM. - `constructor(options: WorkerHostOptions)` - `dispose(): void` - `readonly link: WorkerLink` - `readonly protocol: TProtocol` - `readonly readiness: ThreeBlocksReadiness` - `readonly ready: Promise` - `restart(reason?: string): Promise` - `setStatsPanelMode(mode: VisibleStatsPanelMode): Promise` - `setStatsPanelVisible(visible: boolean): Promise` - `readonly smoke: ThreeBlocksSmokeState` ### WorkerHostOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerHostOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerHostOptions } from "three-blocks/app"; interface WorkerHostOptions ``` **Purpose:** Declares WorkerHostOptions as a public interface. It is exported from three-blocks/app. Its declared surface covers canvas, create, handlers, hot, and onError, plus 5 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerHostOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly canvas: string | HTMLCanvasElement` - `readonly create: () => Worker` - `readonly handlers?: WorkerServerHandlers` - `readonly hot?: AppHotContext | null` - `readonly onError?: (error: unknown) => void` - `readonly protocol?: TProtocol`: Keeps the protocol visible in declarations without adding a runtime option. - `readonly stats?: StatsMainAdapter` - `readonly status?: StatusOverlay` - `readonly text?: boolean` - `readonly validateStructuredClone?: boolean` ### WorkerLifecyclePhase Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerLifecyclePhase. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerLifecyclePhase } from "three-blocks/worker"; type WorkerLifecyclePhase = 'connect' | 'state' | 'event' | 'request' | 'response' | 'transport' | 'dispose' ``` **Purpose:** Declares WorkerLifecyclePhase as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerLifecyclePhase. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WorkerLink Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerLink. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerLink } from "three-blocks/app"; type WorkerLink = WorkerClient ``` **Purpose:** Declares WorkerLink as a public type. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerLink. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WorkerRequestHandlerContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerRequestHandlerContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerRequestHandlerContext } from "three-blocks/worker"; interface WorkerRequestHandlerContext extends WorkerHandlerContext ``` **Purpose:** Declares WorkerRequestHandlerContext as a public interface. It is exported from three-blocks/worker. Its declared surface covers lane and requestId. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerRequestHandlerContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly lane: 'request'` - `readonly requestId: string` ### WorkerRequestHandlers Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerRequestHandlers. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerRequestHandlers } from "three-blocks/worker"; type WorkerRequestHandlers = {[TName in StringKey]?: (parameters: RequestParameters, context: WorkerRequestHandlerContext) => MaybePromise | WorkerTransfer>>;} ``` **Purpose:** Declares WorkerRequestHandlers as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerRequestHandlers. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WorkerRpcLane Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerRpcLane. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerRpcLane } from "three-blocks/worker"; interface WorkerRpcLane ``` **Purpose:** Declares WorkerRpcLane as a public interface. It is exported from three-blocks/worker. Its declared surface covers request. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerRpcLane. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `request>(name: TName, parameters: RequestParameters, options?: SendOptions): Promise>` ### WorkerRuntime Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerRuntime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerRuntime } from "three-blocks/app"; class WorkerRuntime ``` **Purpose:** Shared worker-side assets, shaders, stats, and optional text lifetime. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `applyTextDelivery(delivery: TextSyncDelivery): void` - `readonly assets: AssetManager` - `beginFrame(): void` - `captureStatsFrame(render: StatsTextureRenderer): Promise` - `captureStatsFrame(renderer: WebGPURenderer, scene: Object3D, camera: Camera): Promise` - `captureTexture(name: string, target: object, width?: 90, height?: 48): Promise` - `constructor(options: {readonly installation: ShaderProviderInstallation; readonly assets: AssetManager; readonly shaders: ShaderCache; readonly stats: StatsWorkerAdapter; readonly text?: TextRenderer; readonly sceneKey: string; readonly adapterRuntime: ThreeAssetAdapterRuntime; readonly registrations: Map;})` - `createSceneContext(options?: SceneContextOptions): SceneContext` - `dispose(): Promise` - `endFrame(): void` - `readonly installation: ShaderProviderInstallation` - `replaceTextConfiguration(configuration: TextConfiguration): Promise` - `setStatsPanel(name: string, enabled: boolean, visible: boolean): void` - `readonly shaders: ShaderCache` - `readonly stats: StatsWorkerAdapter` - `readonly text: TextRenderer | undefined` ### WorkerRuntimeConfiguration Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerRuntimeConfiguration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerRuntimeConfiguration } from "three-blocks/app"; interface WorkerRuntimeConfiguration ``` **Purpose:** Declares WorkerRuntimeConfiguration as a public interface. It is exported from three-blocks/app. Its declared surface covers client and loadMeshopt. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerRuntimeConfiguration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly client: ThreeBlocksClientConfig` - `readonly loadMeshopt: () => PromiseLike` ### WorkerServer Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerServer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerServer } from "three-blocks/worker"; class WorkerServer ``` **Purpose:** Worker-side adapter invoking only the explicitly supplied state/event/RPC maps. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor and dispose. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(source: MessageEndpointSource, handlers: WorkerServerHandlers, ...arguments_: CloneableContractArguments)` - `dispose(): void` - `get disposed(): boolean` - `whenIdle(): Promise` ### WorkerServerHandlers Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerServerHandlers. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerServerHandlers } from "three-blocks/worker"; interface WorkerServerHandlers ``` **Purpose:** Declares WorkerServerHandlers as a public interface. It is exported from three-blocks/worker. Its declared surface covers events, requests, and state. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerServerHandlers. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly events?: WorkerEventHandlers` - `readonly requests?: WorkerRequestHandlers` - `readonly state?: WorkerStateHandlers` ### WorkerServerOptions Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerServerOptions. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerServerOptions } from "three-blocks/worker"; interface WorkerServerOptions ``` **Purpose:** Declares WorkerServerOptions as a public interface. It is exported from three-blocks/worker. Its declared surface covers cloneValue, closeEndpointOnDispose, onError, protocolVersion, and source, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerServerOptions. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly cloneValue?: CloneValue` - `readonly closeEndpointOnDispose?: boolean` - `readonly onError?: (error: SerializedWorkerError) => void` - `readonly protocolVersion?: number` - `readonly source?: string` - `readonly validateStructuredClone?: boolean` ### WorkerShaderCaptureActivation Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerShaderCaptureActivation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerShaderCaptureActivation } from "three-blocks/app"; interface WorkerShaderCaptureActivation ``` **Purpose:** Declares WorkerShaderCaptureActivation as a public interface. It is exported from three-blocks/app. Its declared surface covers capture, captureId, driven, forceLive, and readiness, plus 7 other public members. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerShaderCaptureActivation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly capture: boolean` - `readonly captureId?: string` - `readonly driven: boolean` - `readonly forceLive: boolean` - `readonly readiness: {readonly selector?: string; readonly global?: string;}` - `readonly scene: string` - `readonly sessionKey?: string` - `readonly settleFrames: number` - `readonly settleTimeoutMs: number` - `readonly token?: string` - `readonly transform: number` - `readonly visible: boolean` ### WorkerStateHandlerContext Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerStateHandlerContext. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerStateHandlerContext } from "three-blocks/worker"; interface WorkerStateHandlerContext extends WorkerHandlerContext ``` **Purpose:** Declares WorkerStateHandlerContext as a public interface. It is exported from three-blocks/worker. Its declared surface covers lane and sequence. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerStateHandlerContext. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly lane: 'state'` - `readonly sequence: number` ### WorkerStateHandlers Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerStateHandlers. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerStateHandlers } from "three-blocks/worker"; type WorkerStateHandlers = {[TName in StringKey]?: (value: TState[TName], context: WorkerStateHandlerContext) => MaybePromise;} ``` **Purpose:** Declares WorkerStateHandlers as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerStateHandlers. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### WorkerStateLane Kind: interface; canonical: https://threejs-blocks.com/docs/api/WorkerStateLane. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerStateLane } from "three-blocks/worker"; interface WorkerStateLane ``` **Purpose:** Declares WorkerStateLane as a public interface. It is exported from three-blocks/worker. Its declared surface covers clear and set. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerStateLane. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `clear>(name: TName): void` - `set>(name: TName, value: TState[TName], options?: SendOptions): void`: Transfer-bearing state is sent once and cannot be retained for endpoint replay. ### WorkerTransfer Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerTransfer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerTransfer } from "three-blocks/worker"; class WorkerTransfer ``` **Purpose:** Declares WorkerTransfer as a public class. It is exported from three-blocks/worker. Its declared surface covers transfer and value, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `constructor(value: TResult, transfer: readonly object[])` - `readonly transfer: readonly object[]` - `readonly value: TResult` ### WorkerTransportError Kind: class; canonical: https://threejs-blocks.com/docs/api/WorkerTransportError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { WorkerTransportError } from "three-blocks/worker"; class WorkerTransportError extends Error ``` **Purpose:** Declares WorkerTransportError as a public class. It is exported from three-blocks/worker. Its declared surface covers code and serialized, plus 1 other public member. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes these lifecycle-shaped names: constructor. These names describe the callable surface only; the declaration does not establish ownership or invocation order. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. - `readonly code: WorkerTransportErrorCode` - `constructor(code: WorkerTransportErrorCode, message: string, serialized?: SerializedWorkerError)` - `readonly serialized: SerializedWorkerError | undefined` ### WorkerTransportErrorCode Kind: type; canonical: https://threejs-blocks.com/docs/api/WorkerTransportErrorCode. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import type { WorkerTransportErrorCode } from "three-blocks/worker"; type WorkerTransportErrorCode = 'clone-rejected' | 'disposed' | 'endpoint-replaced' | 'invalid-message' | 'missing-handler' | 'no-endpoint' | 'not-connected' | 'protocol-mismatch' | 'remote-error' | 'sequence-error' | 'transport-error' ``` **Purpose:** Declares WorkerTransportErrorCode as a public type. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for WorkerTransportErrorCode. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### asTransferable Kind: function; canonical: https://threejs-blocks.com/docs/api/asTransferable. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { asTransferable } from "three-blocks/worker"; asTransferable(value: TValue): TransferableValue ``` **Purpose:** Identity helper making transfer-only protocol fields visible to the type system. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for asTransferable. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### assertTextSyncBatch Kind: function; canonical: https://threejs-blocks.com/docs/api/assertTextSyncBatch. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { assertTextSyncBatch } from "three-blocks/text"; assertTextSyncBatch(value: unknown): asserts value is TextSyncBatch ``` **Purpose:** Declares assertTextSyncBatch as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for assertTextSyncBatch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### assertTextSyncDelivery Kind: function; canonical: https://threejs-blocks.com/docs/api/assertTextSyncDelivery. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { assertTextSyncDelivery } from "three-blocks/text"; assertTextSyncDelivery(value: unknown): asserts value is TextSyncDelivery ``` **Purpose:** Declares assertTextSyncDelivery as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for assertTextSyncDelivery. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### assertThreeWebGPU186Dev Kind: function; canonical: https://threejs-blocks.com/docs/api/assertThreeWebGPU186Dev. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { assertThreeWebGPU186Dev } from "three-blocks/shaders"; assertThreeWebGPU186Dev(version: string): void ``` **Purpose:** Declares assertThreeWebGPU186Dev as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for assertThreeWebGPU186Dev. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### assertThreeWebGPUR185 Kind: function; canonical: https://threejs-blocks.com/docs/api/assertThreeWebGPUR185. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { assertThreeWebGPUR185 } from "three-blocks/shaders"; assertThreeWebGPUR185(version: string): void ``` **Purpose:** Declares assertThreeWebGPUR185 as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for assertThreeWebGPUR185. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### bindingKindOf Kind: function; canonical: https://threejs-blocks.com/docs/api/bindingKindOf. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { bindingKindOf } from "three-blocks/shaders"; bindingKindOf(binding: ShaderBindingLike): string ``` **Purpose:** Canonical Three.js r185 binding kind, derived from structural `is*` flags and node-ownership fields instead of `constructor.name`. Minified application builds rename classes (Vite's worker-chunk minify pass does not honor `keepNames`), so hydration must never compare function names against captured manifests. The returned strings are the historical r185 class names, keeping previously captured manifests valid. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for bindingKindOf. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### biplanarTexture Kind: variable; canonical: https://threejs-blocks.com/docs/api/biplanarTexture. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { biplanarTexture } from "three-blocks"; import { biplanarTexture } from "three-blocks/core-tsl-effects"; const biplanarTexture: TSLFunction ``` **Purpose:** Efficient biplanar texture mapping for world-space triplanar-style effects. Samples only the two most dominant axis projections and blends them, reducing texture fetches compared to full triplanar mapping. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for biplanarTexture. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. ### captureComponentHotSnapshot Kind: function; canonical: https://threejs-blocks.com/docs/api/captureComponentHotSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { captureComponentHotSnapshot } from "three-blocks/hmr"; captureComponentHotSnapshot(component: Object3D): ComponentHotSnapshot ``` **Purpose:** Declares captureComponentHotSnapshot as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for captureComponentHotSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### childrenOf Kind: function; canonical: https://threejs-blocks.com/docs/api/childrenOf. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { childrenOf } from "three-blocks/shaders"; childrenOf(node: ShaderNodeLike): readonly ShaderNodeLike[] ``` **Purpose:** Direct children in Three.js serialization order. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for childrenOf. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### configureWorkerShaderCapture Kind: function; canonical: https://threejs-blocks.com/docs/api/configureWorkerShaderCapture. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { configureWorkerShaderCapture } from "three-blocks/app"; configureWorkerShaderCapture(activation: WorkerShaderCaptureActivation | undefined): void ``` **Purpose:** Activate the inert dev capture journal before a worker creates its renderer. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for configureWorkerShaderCapture. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### containerRoot Kind: function; canonical: https://threejs-blocks.com/docs/api/containerRoot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { containerRoot } from "three-blocks/shaders"; containerRoot(key: string, context: ShaderAddressContext): object | undefined ``` **Purpose:** Declares containerRoot as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for containerRoot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createAssetLoaderRegistry Kind: function; canonical: https://threejs-blocks.com/docs/api/createAssetLoaderRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createAssetLoaderRegistry } from "three-blocks/assets"; createAssetLoaderRegistry(adapters: TAdapters & AdapterConstraint): AssetLoaderRegistry ``` **Purpose:** Declares createAssetLoaderRegistry as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createAssetLoaderRegistry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createAssetManager Kind: function; canonical: https://threejs-blocks.com/docs/api/createAssetManager. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createAssetManager } from "three-blocks/assets"; createAssetManager(registry: AssetLoaderRegistry, options?: AssetManagerOptions): AssetManager ``` **Purpose:** Declares createAssetManager as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createAssetManager. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createComponentHotRegistry Kind: function; canonical: https://threejs-blocks.com/docs/api/createComponentHotRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createComponentHotRegistry } from "three-blocks/hmr"; createComponentHotRegistry(options?: ComponentHotRegistryOptions): ComponentHotRegistry ``` **Purpose:** Declares createComponentHotRegistry as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createComponentHotRegistry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createDispatcher Kind: function; canonical: https://threejs-blocks.com/docs/api/createDispatcher. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createDispatcher } from "three-blocks/runtime"; createDispatcher(options?: DispatcherOptions): Dispatcher ``` **Purpose:** Declares createDispatcher as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/runtime. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createDispatcher. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/runtime entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createInputForwarder Kind: function; canonical: https://threejs-blocks.com/docs/api/createInputForwarder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createInputForwarder } from "three-blocks/app"; createInputForwarder(worker: WorkerLink): InputForwarder ``` **Purpose:** Declares createInputForwarder as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createInputForwarder. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createSDFBoundsHelper Kind: function; canonical: https://threejs-blocks.com/docs/api/createSDFBoundsHelper. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { createSDFBoundsHelper } from "three-blocks/sdf-raymarching"; createSDFBoundsHelper(sdfGenerator: SDFVolumeBoundsSource, color?: ColorRepresentation): Box3Helper ``` **Purpose:** Creates a Box3Helper for visualizing SDF volume bounds. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createSDFBoundsHelper. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_points_bvh_volume. ### createSDFPointCloudHelper Kind: function; canonical: https://threejs-blocks.com/docs/api/createSDFPointCloudHelper. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { createSDFPointCloudHelper } from "three-blocks/sdf-raymarching"; createSDFPointCloudHelper(sampler: SDFPointCloudSamplerSource, options?: SDFPointCloudHelperOptions): Promise ``` **Purpose:** Creates a point cloud visualization of sampled positions. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createSDFPointCloudHelper. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: none recorded. ### createSceneHotReloader Kind: function; canonical: https://threejs-blocks.com/docs/api/createSceneHotReloader. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createSceneHotReloader } from "three-blocks/hmr"; createSceneHotReloader, TContext, TState = unknown>(initial: TScene, options: SceneHotReloaderOptions): SceneHotReloader ``` **Purpose:** Declares createSceneHotReloader as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createSceneHotReloader. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createShaderCache Kind: function; canonical: https://threejs-blocks.com/docs/api/createShaderCache. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createShaderCache } from "three-blocks/shaders"; createShaderCache(activeScene?: string): ShaderCache ``` **Purpose:** Declares createShaderCache as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createShaderCache. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createStandardAssetLoaderRegistry Kind: function; canonical: https://threejs-blocks.com/docs/api/createStandardAssetLoaderRegistry. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createStandardAssetLoaderRegistry } from "three-blocks/assets"; createStandardAssetLoaderRegistry(adapters: StandardAssetAdapters): AssetLoaderRegistry> ``` **Purpose:** Require an explicit implementation for every standard asset type without importing DOM APIs. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createStandardAssetLoaderRegistry. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createStatsMain Kind: function; canonical: https://threejs-blocks.com/docs/api/createStatsMain. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createStatsMain } from "three-blocks/stats"; createStatsMain(options?: StatsMainOptions): StatsMainAdapter ``` **Purpose:** Declares createStatsMain as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createStatsMain. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createStatsWorker Kind: function; canonical: https://threejs-blocks.com/docs/api/createStatsWorker. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createStatsWorker } from "three-blocks/stats"; createStatsWorker(options: StatsWorkerOptions): StatsWorkerAdapter ``` **Purpose:** Declares createStatsWorker as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/stats. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createStatsWorker. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/stats entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createTextRenderer Kind: function; canonical: https://threejs-blocks.com/docs/api/createTextRenderer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createTextRenderer } from "three-blocks/text/worker"; createTextRenderer(options: TextRendererOptions): TextRenderer ``` **Purpose:** Declares createTextRenderer as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/text/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createTextRenderer. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: https://threejs-blocks.com/examples/webgl_text_input. ### createTextSync Kind: function; canonical: https://threejs-blocks.com/docs/api/createTextSync. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createTextSync } from "three-blocks/text/main"; createTextSync(options: TextSyncOptions): TextSync ``` **Purpose:** Create and start a synchronizer; await `start()` when authoritative font measurement matters. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createTextSync. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text/main entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: https://threejs-blocks.com/examples/webgl_text_input. ### createThreeAssetAdapters Kind: function; canonical: https://threejs-blocks.com/docs/api/createThreeAssetAdapters. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createThreeAssetAdapters } from "three-blocks/assets"; createThreeAssetAdapters(options: CreateThreeAssetAdaptersOptions): ThreeAssetAdapterRuntime ``` **Purpose:** Create the complete standard worker adapter runtime and its typed registry. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createThreeAssetAdapters. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createThreeWebGLShaderCompatibility Kind: function; canonical: https://threejs-blocks.com/docs/api/createThreeWebGLShaderCompatibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createThreeWebGLShaderCompatibility } from "three-blocks/shaders"; createThreeWebGLShaderCompatibility(options: ThreeWebGPUCompatibilityOptions): ShaderCompatibility ``` **Purpose:** Three.js r185 adapter for WebGPURenderer's WebGL fallback backend. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createThreeWebGLShaderCompatibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createThreeWebGPU186DevShaderCompatibility Kind: function; canonical: https://threejs-blocks.com/docs/api/createThreeWebGPU186DevShaderCompatibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createThreeWebGPU186DevShaderCompatibility } from "three-blocks/shaders"; createThreeWebGPU186DevShaderCompatibility(options: ThreeWebGPUCompatibilityOptions): ShaderCompatibility ``` **Purpose:** Declares createThreeWebGPU186DevShaderCompatibility as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createThreeWebGPU186DevShaderCompatibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createThreeWebGPUShaderCompatibility Kind: function; canonical: https://threejs-blocks.com/docs/api/createThreeWebGPUShaderCompatibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createThreeWebGPUShaderCompatibility } from "three-blocks/shaders"; createThreeWebGPUShaderCompatibility(options: ThreeWebGPUCompatibilityOptions): ShaderCompatibility ``` **Purpose:** Central r185 adapter. This is the only public runtime module allowed to touch the provider hook and Three.js node-builder internals. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createThreeWebGPUShaderCompatibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createWaterComposite Kind: function; canonical: https://threejs-blocks.com/docs/api/createWaterComposite. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { createWaterComposite } from "three-blocks/water"; createWaterComposite(surface: WaterCompositeSurface, {sceneColorNode, sceneDepthNode, surfaceField, surfaceFoam, worldToVolume, envNode, uvNode, compositeWhitewater, physicalRefraction: physicalRefractionEnabled, ssr, caustics, sunShadowNode, detailNormals, contactFoam, dispersion, glitter, reducedMotion, underwater: underwaterEnabled, uniforms: uniformOverrides,}?: WaterCompositeOptions): WaterCompositeResult ``` **Purpose:** Full-resolution SSF water composite. Foam is treated as a rough, porous material rather than white paint; thickness is bounded before absorption; reflections can sample a PMREM environment; and thin backlit crests receive a wrapped subsurface term. The renderer's density buffer is composited once, so overlapping whitewater sprites brighten sub-linearly. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createWaterComposite. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. ### createWorkerClient Kind: function; canonical: https://threejs-blocks.com/docs/api/createWorkerClient. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createWorkerClient } from "three-blocks/worker"; createWorkerClient(...arguments_: CloneableContractArguments): WorkerClient ``` **Purpose:** Declares createWorkerClient as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createWorkerClient. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createWorkerRuntime Kind: function; canonical: https://threejs-blocks.com/docs/api/createWorkerRuntime. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createWorkerRuntime } from "three-blocks/app"; createWorkerRuntime(options: CreateWorkerRuntimeOptions): Promise ``` **Purpose:** Declares createWorkerRuntime as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createWorkerRuntime. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### createWorkerServer Kind: function; canonical: https://threejs-blocks.com/docs/api/createWorkerServer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { createWorkerServer } from "three-blocks/worker"; createWorkerServer(endpoint: MessageEndpointSource, handlers: WorkerServerHandlers, ...arguments_: CloneableContractArguments): WorkerServer ``` **Purpose:** Declares createWorkerServer as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for createWorkerServer. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### curlNoise Kind: variable; canonical: https://threejs-blocks.com/docs/api/curlNoise. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { curlNoise } from "three-blocks/experimental/core-tsl-effects"; const curlNoise: TSLFunction ``` **Purpose:** Divergence-free curl noise vector field (incompressible swirling flow). **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for curlNoise. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/experimental/core-tsl-effects entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### currentWorkerShaderCaptureActivation Kind: function; canonical: https://threejs-blocks.com/docs/api/currentWorkerShaderCaptureActivation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { currentWorkerShaderCaptureActivation } from "three-blocks/app"; currentWorkerShaderCaptureActivation(): WorkerShaderCaptureActivation | undefined ``` **Purpose:** Read the dev-overlay capture session prepared before the application module starts. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for currentWorkerShaderCaptureActivation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### default Kind: function; canonical: https://threejs-blocks.com/docs/api/default. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import threeBlocks from "three-blocks/vite"; default(options?: ThreeBlocksViteOptions): ThreeBlocksVitePlugin ``` **Purpose:** Configure Vite for a single Three.js instance, worker ESM, stable TSL names, runtime codec delivery, and typed compile-time application state. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for default. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### defineAssetAdapter Kind: function; canonical: https://threejs-blocks.com/docs/api/defineAssetAdapter. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { defineAssetAdapter } from "three-blocks/assets"; defineAssetAdapter(adapter: AssetAdapter): AssetAdapter ``` **Purpose:** Declares defineAssetAdapter as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/assets. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for defineAssetAdapter. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### defineAssets Kind: function; canonical: https://threejs-blocks.com/docs/api/defineAssets. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { defineAssets } from "three-blocks/assets"; defineAssets>>(manifest: TManifest): TManifest ``` **Purpose:** Preserve literal names, resource types, and required/optional flags for result inference. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for defineAssets. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/assets entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### definePrecompiledManifest Kind: function; canonical: https://threejs-blocks.com/docs/api/definePrecompiledManifest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { definePrecompiledManifest } from "three-blocks/shaders"; definePrecompiledManifest(manifest: TManifest): TManifest ``` **Purpose:** Preserve literal scene/key inference for generated TypeScript manifests. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for definePrecompiledManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### defineText Kind: function; canonical: https://threejs-blocks.com/docs/api/defineText. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { defineText } from "three-blocks/text"; defineText>>(configuration: TextConfiguration): TextConfiguration & {readonly schemaVersion: typeof TEXT_SCHEMA_VERSION;} ``` **Purpose:** Preserve literal font keys while validating the public generation/runtime contract. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for defineText. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: https://threejs-blocks.com/examples/webgl_text_input. ### defineTextContent Kind: function; canonical: https://threejs-blocks.com/docs/api/defineTextContent. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { defineTextContent } from "three-blocks/text"; defineTextContent(content: TContent): TContent ``` **Purpose:** Marker understood by semantic glyph extraction; source files are not scanned indiscriminately. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for defineTextContent. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### emptyPrecompiledManifest Kind: function; canonical: https://threejs-blocks.com/docs/api/emptyPrecompiledManifest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { emptyPrecompiledManifest } from "three-blocks/shaders"; emptyPrecompiledManifest(scene: string): PrecompiledManifest ``` **Purpose:** An empty manifest for observers and coverage baselines. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for emptyPrecompiledManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### errorMessage Kind: function; canonical: https://threejs-blocks.com/docs/api/errorMessage. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { errorMessage } from "three-blocks/app"; errorMessage(error: unknown): string ``` **Purpose:** Declares errorMessage as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/app. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for errorMessage. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### filmHD Kind: variable; canonical: https://threejs-blocks.com/docs/api/filmHD. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { filmHD } from "three-blocks"; import { filmHD } from "three-blocks/core-tsl-effects"; const filmHD: FilmHDNodeFactory ``` **Purpose:** Cinematic film grain with blue noise, scanlines, and temporal stability. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for filmHD. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. ### formatThreeBlocksBuildReceipt Kind: function; canonical: https://threejs-blocks.com/docs/api/formatThreeBlocksBuildReceipt. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { formatThreeBlocksBuildReceipt } from "three-blocks/vite"; formatThreeBlocksBuildReceipt(receipt: ThreeBlocksBuildReceipt): string ``` **Purpose:** Format the human receipt from the same state exposed to automation. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for formatThreeBlocksBuildReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### fresnel Kind: variable; canonical: https://threejs-blocks.com/docs/api/fresnel. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { fresnel } from "three-blocks"; import { fresnel } from "three-blocks/core-tsl-effects"; const fresnel: TSLFunction ``` **Purpose:** Fresnel effect TSL function. Computes a view-dependent falloff based on the angle between surface normal and view direction. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for fresnel. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. ### gaussianAAFactor Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianAAFactor. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianAAFactor } from "three-blocks/gaussian-splats"; const gaussianAAFactor: import("three/webgpu").Node<"float"> ``` **Purpose:** Anti-aliasing compensation factor (float). Compensates alpha for intensity reduction from low-pass filtering. Unpacked from vPackedData.y. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianAAFactor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianAlphaUV Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianAlphaUV. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianAlphaUV } from "three-blocks/gaussian-splats"; const gaussianAlphaUV: TSLFunction<[TSLVec2Input], TSLFloatNode> ``` **Purpose:** Compute Gaussian alpha falloff using UV coordinates. Uses SuperSplat's normalized exponential formula for clean quad edges. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianAlphaUV. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianColor Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianColor. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianColor } from "three-blocks/gaussian-splats"; const gaussianColor: import("three/webgpu").PropertyNode<"vec4"> ``` **Purpose:** Splat color from SH evaluation (vec4: rgba). Contains pre-computed spherical harmonics color. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianColor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianDepth Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianDepth. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianDepth } from "three-blocks/gaussian-splats"; const gaussianDepth: import("three/webgpu").Node<"float"> ``` **Purpose:** NDC depth value in [0,1] range (float). Pre-computed in vertex shader for perfect sync with scene depth. 0 = near plane, 1 = far plane. Unpacked from vPackedData.z. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianDepth. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianHue Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianHue. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianHue } from "three-blocks/gaussian-splats"; const gaussianHue: TSLFunction<[GaussianVec3Input], TSLVec3Node> ``` **Purpose:** Extract hue from RGB color and map to RGB wheel for visualization. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianHue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianLuminance Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianLuminance. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianLuminance } from "three-blocks/gaussian-splats"; const gaussianLuminance: TSLFunction<[GaussianVec3Input], TSLFloatNode> ``` **Purpose:** Compute luminance from RGB color using standard coefficients. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianLuminance. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianNormal Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianNormal. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianNormal } from "three-blocks/gaussian-splats"; const gaussianNormal: import("three/webgpu").PropertyNode<"vec3"> ``` **Purpose:** View-space normal from 3D Gaussian ellipsoid (vec3). Computed from the smallest scale axis (flattest direction). Pre-flipped to face camera in the vertex shader. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianNormal. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianPower Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianPower. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianPower } from "three-blocks/gaussian-splats"; const gaussianPower: TSLFunction<[TSLVec2Input], TSLFloatNode> ``` **Purpose:** Compute Gaussian power (exponent) and normalize to 0-1. Returns 1 at center, 0 at edge (inverted for visualization). **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianPower. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianSH Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianSH. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianSH } from "three-blocks/gaussian-splats"; const gaussianSH: import("three/webgpu").Node<"float"> ``` **Purpose:** Spherical Harmonics contribution magnitude (float). Computed as length of gaussianSHColor. Use this to visualize where and how strongly SH affects the rendering. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianSH. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianSHColor Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianSHColor. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianSHColor } from "three-blocks/gaussian-splats"; const gaussianSHColor: import("three/webgpu").PropertyNode<"vec3"> ``` **Purpose:** Full RGB Spherical Harmonics contribution (vec3). View-dependent color delta from base DC color. Used by material to apply shStrength: finalColor = baseColor + shColor * shStrength **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianSHColor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### gaussianUV Kind: variable; canonical: https://threejs-blocks.com/docs/api/gaussianUV. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { gaussianUV } from "three-blocks/gaussian-splats"; const gaussianUV: import("three/webgpu").PropertyNode<"vec2"> ``` **Purpose:** UV coordinates in normalized -1 to 1 range (vec2). At an axis-aligned quad edge: UV = ±1.0. **Status:** Stable through the curated Gaussian Splats block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for gaussianUV. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/gaussian-splats. Curated compatibility: WebGPU only renderer; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/gaussian-splats Direct example imports: https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer. ### getAtlasesInfo Kind: function; canonical: https://threejs-blocks.com/docs/api/getAtlasesInfo. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { getAtlasesInfo } from "three-blocks/experimental/runtime-sdf-text"; getAtlasesInfo(): SDFAtlasInfo[] ``` **Purpose:** Lightweight atlas metrics for monitoring, without logging image data. **Status:** Experimental through the curated Runtime SDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for getAtlasesInfo. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/runtime-sdf-text. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/runtime-sdf-text Direct example imports: none recorded. ### getWaterRayMarchQualityPreset Kind: function; canonical: https://threejs-blocks.com/docs/api/getWaterRayMarchQualityPreset. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { getWaterRayMarchQualityPreset } from "three-blocks/water"; getWaterRayMarchQualityPreset(name?: string): WaterRayMarchQualitySettings ``` **Purpose:** Return a mutable copy of a named raymarch quality tier. **Status:** Stable through the curated Water block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for getWaterRayMarchQualityPreset. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/water. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/water Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_water_ocean. ### indexNodeGraph Kind: function; canonical: https://threejs-blocks.com/docs/api/indexNodeGraph. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { indexNodeGraph } from "three-blocks/shaders"; indexNodeGraph(root: ShaderNodeLike): ReadonlyMap ``` **Purpose:** Deterministic breadth-first node index used by public capture tooling. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for indexNodeGraph. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### inspectThreeBlocksProject Kind: function; canonical: https://threejs-blocks.com/docs/api/inspectThreeBlocksProject. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { inspectThreeBlocksProject } from "three-blocks/vite"; inspectThreeBlocksProject(root: string, options: InspectThreeBlocksProjectOptions): Promise ``` **Purpose:** Declares inspectThreeBlocksProject as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/vite. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for inspectThreeBlocksProject. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### installAutomaticShaderHydration Kind: function; canonical: https://threejs-blocks.com/docs/api/installAutomaticShaderHydration. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { installAutomaticShaderHydration } from "three-blocks/shaders"; installAutomaticShaderHydration(renderer: object): AutomaticShaderHydration ``` **Purpose:** Discover and install the convention manifest while holding the renderer's first build entry points. This makes the existing `registerDevtools({renderer})` line sufficient even though static-asset loading is asynchronous. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for installAutomaticShaderHydration. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### installShaderCache Kind: function; canonical: https://threejs-blocks.com/docs/api/installShaderCache. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { installShaderCache } from "three-blocks/shaders"; installShaderCache(options: InstallShaderCacheOptions): Promise ``` **Purpose:** Load and install only the active scene's provider. Stale/invalid/missing states never call the manifest loader, so old lazy chunks cannot accidentally inject. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for installShaderCache. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### installSmokeBridge Kind: function; canonical: https://threejs-blocks.com/docs/api/installSmokeBridge. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { installSmokeBridge } from "three-blocks/app"; installSmokeBridge(host: WorkerHost): () => void ``` **Purpose:** Install the stable browser-smoke globals without exposing their ledger in app code. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for installSmokeBridge. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### installSmokeBridgeSource Kind: function; canonical: https://threejs-blocks.com/docs/api/installSmokeBridgeSource. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { installSmokeBridgeSource } from "three-blocks/app"; installSmokeBridgeSource(source: SmokeBridgeSource): () => void ``` **Purpose:** Install the stable browser-smoke globals for a custom structural app shell. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for installSmokeBridgeSource. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### instanceCullingIndex Kind: variable; canonical: https://threejs-blocks.com/docs/api/instanceCullingIndex. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { instanceCullingIndex } from "three-blocks/instance-culling"; const instanceCullingIndex: (culler: ComputeInstanceCulling | null | undefined) => Node<"uint"> ``` **Purpose:** Return the original source-instance ID selected by a culling facade. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for instanceCullingIndex. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### instanceCullingMatrix Kind: variable; canonical: https://threejs-blocks.com/docs/api/instanceCullingMatrix. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { instanceCullingMatrix } from "three-blocks/instance-culling"; const instanceCullingMatrix: (culler: ComputeInstanceCulling | null | undefined, idNode?: Node<"int"> | Node<"uint">) => Node<"mat4"> | null ``` **Purpose:** Return a source instance matrix selected through a culling facade. **Status:** Stable through the curated Instance Culling block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for instanceCullingMatrix. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/instance-culling. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/instance-culling Direct example imports: none recorded. ### isAppStatsControl Kind: function; canonical: https://threejs-blocks.com/docs/api/isAppStatsControl. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { isAppStatsControl } from "three-blocks/app"; isAppStatsControl(value: unknown): value is AppStatsControl ``` **Purpose:** Validate an app stats control at a worker transport boundary. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for isAppStatsControl. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### isTextSyncBatch Kind: function; canonical: https://threejs-blocks.com/docs/api/isTextSyncBatch. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { isTextSyncBatch } from "three-blocks/text"; isTextSyncBatch(value: unknown): value is TextSyncBatch ``` **Purpose:** Declares isTextSyncBatch as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for isTextSyncBatch. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### isTextSyncDelivery Kind: function; canonical: https://threejs-blocks.com/docs/api/isTextSyncDelivery. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { isTextSyncDelivery } from "three-blocks/text"; isTextSyncDelivery(value: unknown): value is TextSyncDelivery ``` **Purpose:** Declares isTextSyncDelivery as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/text. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for isTextSyncDelivery. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/text entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### kuwahara Kind: variable; canonical: https://threejs-blocks.com/docs/api/kuwahara. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { kuwahara } from "three-blocks"; import { kuwahara } from "three-blocks/core-tsl-effects"; const kuwahara: KuwaharaNodeFactory ``` **Purpose:** Generalized anisotropic Kuwahara painterly filter with multi-sector sampling. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for kuwahara. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. ### loadThreeBlocksMeshoptDecoder Kind: function; canonical: https://threejs-blocks.com/docs/api/loadThreeBlocksMeshoptDecoder. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { loadThreeBlocksMeshoptDecoder } from "three-blocks/vite/config"; loadThreeBlocksMeshoptDecoder(): Promise ``` **Purpose:** Lazy, browser/worker-safe Meshopt resolution. No project codec file is emitted. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for loadThreeBlocksMeshoptDecoder. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### messageEndpoint Kind: function; canonical: https://threejs-blocks.com/docs/api/messageEndpoint--case-6d-65-73-73-61-67-65-45-6e-64-70-6f-69-6e-74. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { messageEndpoint } from "three-blocks/worker"; messageEndpoint(source: MessageEndpointSource): MessageEndpoint ``` **Purpose:** Normalize a native Worker, MessagePort, worker global, or test adapter once. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for messageEndpoint. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### mountDevtoolsOverlay Kind: variable; canonical: https://threejs-blocks.com/docs/api/mountDevtoolsOverlay. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { mountDevtoolsOverlay } from "three-blocks/devtools"; const mountDevtoolsOverlay: typeof mountThreeBlocksDevOverlay ``` **Purpose:** Mount or update the development overlay used by the example gallery and custom apps. Returns `null` outside a browser or in production. The returned handle owns its DOM and must be disposed when its page-level integration is removed. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for mountDevtoolsOverlay. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### observeThreeBlocksTslBuilds Kind: function; canonical: https://threejs-blocks.com/docs/api/observeThreeBlocksTslBuilds. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { observeThreeBlocksTslBuilds } from "three-blocks/devtools"; observeThreeBlocksTslBuilds(renderer: object, options?: ObserveThreeBlocksTslBuildsOptions): ThreeBlocksTslBuildObserver ``` **Purpose:** Observe Three.js NodeBuilder work created by a WebGPURenderer's backend. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for observeThreeBlocksTslBuilds. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### parallaxOcclusion Kind: variable; canonical: https://threejs-blocks.com/docs/api/parallaxOcclusion. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { parallaxOcclusion } from "three-blocks"; import { parallaxOcclusion } from "three-blocks/core-tsl-effects"; const parallaxOcclusion: TSLFunction ``` **Purpose:** Builds adaptive parallax-occlusion mapping from a height texture and returns displaced UVs plus a depth offset. Optional blue-noise jitter reduces ray-march banding. **Status:** Stable through the curated Core TSL effects block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parallaxOcclusion. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/core-tsl-effects. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/core-tsl-effects Direct example imports: none recorded. ### paramToFrame Kind: variable; canonical: https://threejs-blocks.com/docs/api/paramToFrame. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { paramToFrame } from "three-blocks/baked-motion"; const paramToFrame: (manifest: BakedMotionManifest, values: BakedMotionParameterValues) => BakedMotionFrameSample ``` **Purpose:** Map authored mode parameters to the stored frame indices and interpolation weights. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for paramToFrame. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: https://threejs-blocks.com/examples/webgpu_baked_motion_rotation, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_baked_motion_timeline. ### parseActiveFrameManifest Kind: function; canonical: https://threejs-blocks.com/docs/api/parseActiveFrameManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { parseActiveFrameManifest } from "three-blocks/experimental/active-frame-video"; parseActiveFrameManifest(buffer: ArrayBuffer): ActiveFrameManifest ``` **Purpose:** Validate an ActiveFrame container and return its normalized, versioned runtime manifest. Valid earlier container variants are normalized in memory; malformed bytes and unsupported versions throw. **Status:** Experimental through the curated ActiveFrame Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseActiveFrameManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/active-frame-video. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/active-frame-video Direct example imports: none recorded. ### parseBakedMotionManifest Kind: variable; canonical: https://threejs-blocks.com/docs/api/parseBakedMotionManifest. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { parseBakedMotionManifest } from "three-blocks/baked-motion"; const parseBakedMotionManifest: (input: unknown) => BakedMotionManifest ``` **Purpose:** Validate and normalize an unknown Baked Motion manifest. Throws when the discriminator, version, axes, tracks, camera, or bounds are invalid. **Status:** Stable through the curated Baked Motion block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseBakedMotionManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/baked-motion. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/baked-motion Direct example imports: none recorded. ### parseMSDFFont Kind: function; canonical: https://threejs-blocks.com/docs/api/parseMSDFFont. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { parseMSDFFont } from "three-blocks/msdf-text"; parseMSDFFont(json: unknown, {flipY}?: ParseMSDFFontOptions): MSDFFont ``` **Purpose:** Parses MSDF font metadata JSON into an MSDFFont. **Status:** Stable through the curated MSDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseMSDFFont. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/msdf-text. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/msdf-text Direct example imports: https://threejs-blocks.com/examples/webgpu_text_msdf_batched, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. ### parseOAVManifest Kind: variable; canonical: https://threejs-blocks.com/docs/api/parseOAVManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { parseOAVManifest } from "three-blocks/experimental/object-animation-video"; const parseOAVManifest: (input: unknown) => ObjectAnimationVideoManifest ``` **Purpose:** Validate and freeze an unknown Object Animation Video manifest. Throws when its discriminator, version, transform layout, object table, or track is invalid. **Status:** Experimental through the curated Object Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseOAVManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/object-animation-video. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/object-animation-video Direct example imports: none recorded. ### parsePrecompiledManifest Kind: function; canonical: https://threejs-blocks.com/docs/api/parsePrecompiledManifest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { parsePrecompiledManifest } from "three-blocks/shaders"; parsePrecompiledManifest(value: unknown): PrecompiledManifest ``` **Purpose:** Declares parsePrecompiledManifest as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parsePrecompiledManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### parseVAVBase Kind: variable; canonical: https://threejs-blocks.com/docs/api/parseVAVBase. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { parseVAVBase } from "three-blocks/experimental/vertex-animation-video"; const parseVAVBase: (buffer: ArrayBuffer, manifest: Readonly>) => VAVBase ``` **Purpose:** Parse and cross-check a VAV `base.bin` topology sidecar. Throws when the sidecar is truncated or disagrees with the validated manifest. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseVAVBase. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### parseVAVManifest Kind: variable; canonical: https://threejs-blocks.com/docs/api/parseVAVManifest. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { parseVAVManifest } from "three-blocks/experimental/vertex-animation-video"; const parseVAVManifest: (input: unknown) => VAVManifest ``` **Purpose:** Validate and freeze an unknown Vertex Animation Video manifest. Throws on a wrong version, malformed bounds/topology, or inconsistent track indices. **Status:** Experimental through the curated Vertex Animation Video block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for parseVAVManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/vertex-animation-video. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/vertex-animation-video Direct example imports: none recorded. ### registerDevtools Kind: function; canonical: https://threejs-blocks.com/docs/api/registerDevtools. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { registerDevtools } from "three-blocks/devtools"; registerDevtools(options: RegisterDevtoolsOptions): DevtoolsRegistration | null ``` **Purpose:** Attach the dev overlay stats control to an existing page-owned renderer. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for registerDevtools. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/devtools entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: https://threejs-blocks.com/examples/webgl_postprocessing_smoke, https://threejs-blocks.com/examples/webgl_text_input, https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect, https://threejs-blocks.com/examples/webgpu_baked_motion_rotation, https://threejs-blocks.com/examples/webgpu_baked_motion_tilt, https://threejs-blocks.com/examples/webgpu_baked_motion_timeline, https://threejs-blocks.com/examples/webgpu_gaussiansplat_4dgs_video, https://threejs-blocks.com/examples/webgpu_gaussiansplat_lit, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_lion, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_scene, https://threejs-blocks.com/examples/webgpu_gaussiansplat_splat, https://threejs-blocks.com/examples/webgpu_gaussiansplat_visualizer, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_material_transmission, https://threejs-blocks.com/examples/webgpu_points_bvh_volume, https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d, https://threejs-blocks.com/examples/webgpu_simulation_water_compute, https://threejs-blocks.com/examples/webgpu_simulation_water_ocean, https://threejs-blocks.com/examples/webgpu_text_msdf_batched, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned, https://threejs-blocks.com/examples/webgpu_vav_basic. ### resolveContainerValue Kind: function; canonical: https://threejs-blocks.com/docs/api/resolveContainerValue. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { resolveContainerValue } from "three-blocks/shaders"; resolveContainerValue(root: object, path: readonly ShaderPathSegment[]): unknown ``` **Purpose:** Declares resolveContainerValue as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for resolveContainerValue. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### resolveNodeAddress Kind: function; canonical: https://threejs-blocks.com/docs/api/resolveNodeAddress. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { resolveNodeAddress } from "three-blocks/shaders"; resolveNodeAddress(address: NodeAddress, context: ShaderAddressContext, compatibility: ShaderCompatibility): ShaderNodeLike ``` **Purpose:** Resolve an already validated manifest address against the active scene only. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for resolveNodeAddress. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### resolveNodePath Kind: function; canonical: https://threejs-blocks.com/docs/api/resolveNodePath. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { resolveNodePath } from "three-blocks/shaders"; resolveNodePath(root: ShaderNodeLike, path: readonly number[]): ShaderNodeLike | undefined ``` **Purpose:** Declares resolveNodePath as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for resolveNodePath. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### restoreComponentHotSnapshot Kind: function; canonical: https://threejs-blocks.com/docs/api/restoreComponentHotSnapshot. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { restoreComponentHotSnapshot } from "three-blocks/hmr"; restoreComponentHotSnapshot(component: Object3D, snapshot: ComponentHotSnapshot): void ``` **Purpose:** Declares restoreComponentHotSnapshot as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/hmr. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for restoreComponentHotSnapshot. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### runtimeStageReached Kind: function; canonical: https://threejs-blocks.com/docs/api/runtimeStageReached. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { runtimeStageReached } from "three-blocks/app"; runtimeStageReached(stage: RuntimeStage, milestone: RuntimeStage): boolean ``` **Purpose:** True when a lifecycle stage has reached or passed the requested milestone. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for runtimeStageReached. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### serializeWorkerError Kind: function; canonical: https://threejs-blocks.com/docs/api/serializeWorkerError. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { serializeWorkerError } from "three-blocks/worker"; serializeWorkerError(error: unknown, options: SerializeWorkerErrorOptions): SerializedWorkerError ``` **Purpose:** Declares serializeWorkerError as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for serializeWorkerError. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### setWorkerShaderCaptureVisibility Kind: function; canonical: https://threejs-blocks.com/docs/api/setWorkerShaderCaptureVisibility. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { setWorkerShaderCaptureVisibility } from "three-blocks/app"; setWorkerShaderCaptureVisibility(visible: boolean): void ``` **Purpose:** Keep a worker capture's settle window aligned with page visibility. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for setWorkerShaderCaptureVisibility. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/app entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### shaderCache Kind: variable; canonical: https://threejs-blocks.com/docs/api/shaderCache--case-73-68-61-64-65-72-43-61-63-68-65. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { shaderCache } from "three-blocks/shaders"; const shaderCache: ShaderCache ``` **Purpose:** Optional shared registry for concise generated-app registration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for shaderCache. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: https://threejs-blocks.com/examples/webgl_text_input, https://threejs-blocks.com/examples/webgpu_animation_texture_object_indirect, https://threejs-blocks.com/examples/webgpu_gaussiansplat_lit, https://threejs-blocks.com/examples/webgpu_gaussiansplat_mesh_to_splat_scene, https://threejs-blocks.com/examples/webgpu_gaussiansplat_splat, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh, https://threejs-blocks.com/examples/webgpu_indirect_batchedmesh_visibility, https://threejs-blocks.com/examples/webgpu_material_transmission, https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_boids_3d, https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d, https://threejs-blocks.com/examples/webgpu_simulation_water_compute, https://threejs-blocks.com/examples/webgpu_simulation_water_ocean, https://threejs-blocks.com/examples/webgpu_text_msdf_batched, https://threejs-blocks.com/examples/webgpu_text_sampler_skinned. ### shimKtx2WorkerBodyForTests Kind: variable; canonical: https://threejs-blocks.com/docs/api/shimKtx2WorkerBodyForTests. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { shimKtx2WorkerBodyForTests } from "three-blocks/vite"; const shimKtx2WorkerBodyForTests: (body: string) => string ``` **Purpose:** Test seam for the injected worker keep-names shim. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for shimKtx2WorkerBodyForTests. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### smoke Kind: variable; canonical: https://threejs-blocks.com/docs/api/smoke. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { smoke } from "three-blocks/smoke"; const smoke: (pointer?: SmokeNodePointerInput | undefined, simRes?: number, dyeRes?: number, iterations?: number, densityDissipation?: number, velocityDissipation?: number, pressureDissipation?: number, curlStrength?: number, pressureFactor?: number, radius?: number, useBoundaries?: boolean, pointerScale?: number, neighborStride?: number, speedFactor?: number) => SmokeNodeResult ``` **Purpose:** Create the runtime-identical compact 2D smoke TSL node. Invalid resolutions or unsupported renderer capabilities can fail during setup or the first frame. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for smoke. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgl_postprocessing_smoke. ### smokeRTT Kind: variable; canonical: https://threejs-blocks.com/docs/api/smokeRTT. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { smokeRTT } from "three-blocks/smoke"; const smokeRTT: (pointer?: SmokePointerInput | undefined, simRes?: number, dyeRes?: number, iterations?: number, densityDissipation?: number, velocityDissipation?: number, pressureDissipation?: number, curlStrength?: number, pressureFactor?: number, radius?: number, useBoundaries?: boolean, pointerScale?: number, neighborStride?: number, speedFactor?: number) => SmokeNodeRTTResult ``` **Purpose:** Smoke RTT Simulation (TSL) – a 2D velocity–pressure solver using RenderTargets. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for smokeRTT. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgl_postprocessing_smoke, https://threejs-blocks.com/examples/webgpu_text_msdf_batched. ### spatialLookupInternals Kind: variable; canonical: https://threejs-blocks.com/docs/api/spatialLookupInternals. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { spatialLookupInternals } from "three-blocks/boids"; const spatialLookupInternals: {cell_offsets_2d: TSLUniformArrayNode<"ivec2">; cell_offsets_3d: TSLUniformArrayNode<"ivec3">;} ``` **Purpose:** TSL spatial-lookup offset nodes exposed for shader precompilation and rehydration. **Status:** Stable through the curated Boids block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for spatialLookupInternals. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/boids. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/boids Direct example imports: none recorded. ### sphereImpostorAlpha Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorAlpha. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorAlpha } from "three-blocks/sphere-impostors"; const sphereImpostorAlpha: TSLFunction<[], TSLFloatNode> ``` **Purpose:** Produce cutout alpha whose 0.5 crossing is the unit-circle silhouette. Assign this to opacityNode and set material.alphaTest to 0.5. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorAlpha. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### sphereImpostorDepth Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorDepth. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorDepth } from "three-blocks/sphere-impostors"; const sphereImpostorDepth: TSLFunction<[], TSLFloatNode> ``` **Purpose:** Reconstruct projection-correct sphere depth from a view-space ray intersection. The result is converted to the renderer's [0,1] depth convention for perspective/orthographic and normal/reversed-depth configurations. Assigning this node to material.depthNode is optional because fragment-depth writes disable early depth rejection for the draw. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorDepth. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking. ### sphereImpostorNormal Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorNormal. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorNormal } from "three-blocks/sphere-impostors"; const sphereImpostorNormal: TSLFunction<[], TSLVec3Node> ``` **Purpose:** Alias for sphereImpostorNormalView(), intended for NodeMaterial.normalNode. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorNormal. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### sphereImpostorPosition Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorPosition. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorPosition } from "three-blocks"; import { sphereImpostorPosition } from "three-blocks/sphere-impostors"; const sphereImpostorPosition: TSLFunction<[config: SphereImpostorPositionConfig], TSLVec3Node> ``` **Purpose:** Assemble an equilateral, camera-facing triangle around a particle center. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorPosition. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks and three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: https://threejs-blocks.com/examples/webgpu_sdf_body_tracking, https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### sphereImpostorShadow Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorShadow. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorShadow } from "three-blocks/sphere-impostors"; const sphereImpostorShadow: TSLFunction<[], TSLVec4Node> ``` **Purpose:** Produce a shadow color carrying the same circular alpha cutout as the beauty pass. Assign this to material.castShadowNode while keeping alphaTest at 0.5. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorShadow. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_sph_3d. ### sphereImpostorSurfaceNormal Kind: variable; canonical: https://threejs-blocks.com/docs/api/sphereImpostorSurfaceNormal. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { sphereImpostorSurfaceNormal } from "three-blocks/sphere-impostors"; const sphereImpostorSurfaceNormal: TSLFunction<[], TSLVec3Node> ``` **Purpose:** Alias for sphereImpostorSurfaceNormalView(), intended for NodeMaterial.normalNode. **Status:** Stable through the curated Sphere impostors block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for sphereImpostorSurfaceNormal. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sphere-impostors. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sphere-impostors Direct example imports: none recorded. ### stateKind Kind: function; canonical: https://threejs-blocks.com/docs/api/stateKind. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { stateKind } from "three-blocks/shaders"; stateKind(state: Pick): ShaderBuildKind ``` **Purpose:** Build kind of one pooled state. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for stateKind. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### structureTensor Kind: variable; canonical: https://threejs-blocks.com/docs/api/structureTensor. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { structureTensor } from "three-blocks/experimental/core-tsl-effects"; const structureTensor: StructureTensorNodeFactory ``` **Purpose:** Compute structure tensor for edge-aware image filtering. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for structureTensor. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/experimental/core-tsl-effects entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### textDrawId Kind: variable; canonical: https://threejs-blocks.com/docs/api/textDrawId. Package version: 0.10.0; Classification: curated-block; Status: experimental; Since: Not recorded; Deprecated: No. ```ts import { textDrawId } from "three-blocks/experimental/runtime-sdf-text"; const textDrawId: TSLFloatNode ``` **Purpose:** Draw/member ID as a float. For single Text instances, this is always 0. For BatchedText, this is the index of the text member within the batch. **Status:** Experimental through the curated Runtime SDF Text block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for textDrawId. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/experimental/runtime-sdf-text. Curated compatibility: WebGPU and WebGL renderers; browser and worker environments. Curated block: https://threejs-blocks.com/docs/blocks/runtime-sdf-text Direct example imports: none recorded. ### threeBlocks Kind: function; canonical: https://threejs-blocks.com/docs/api/threeBlocks. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocks } from "three-blocks/vite"; threeBlocks(options?: ThreeBlocksViteOptions): ThreeBlocksVitePlugin ``` **Purpose:** Configure Vite for a single Three.js instance, worker ESM, stable TSL names, runtime codec delivery, and typed compile-time application state. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocks. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksAssets Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksAssets. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksAssets } from "three-blocks/vite/config"; const threeBlocksAssets: ThreeBlocksAssetBuildConfig ``` **Purpose:** Declares threeBlocksAssets as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksAssets. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksBuildReceipt Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksBuildReceipt--case-74-68-72-65-65-42-6c-6f-63-6b-73-42-75-69-6c-64-52-65-63-65-69-70-74. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksBuildReceipt } from "three-blocks/vite/config"; const threeBlocksBuildReceipt: ThreeBlocksBuildReceipt ``` **Purpose:** Declares threeBlocksBuildReceipt as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksBuildReceipt. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksCapture Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksCapture. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksCapture } from "three-blocks/vite/config"; const threeBlocksCapture: ThreeBlocksShaderCaptureBuildConfig | undefined ``` **Purpose:** Declares threeBlocksCapture as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksCapture. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksConfig Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksConfig. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksConfig } from "three-blocks/vite/config"; const threeBlocksConfig: ThreeBlocksClientConfig ``` **Purpose:** Declares threeBlocksConfig as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksConfig. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksDevelopment Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksDevelopment. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksDevelopment } from "three-blocks/vite/config"; const threeBlocksDevelopment: boolean ``` **Purpose:** Declares threeBlocksDevelopment as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksDevelopment. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksShaders Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksShaders. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksShaders } from "three-blocks/vite/config"; const threeBlocksShaders: ThreeBlocksShaderBuildConfig ``` **Purpose:** Declares threeBlocksShaders as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksShaders. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksStats Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksStats. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksStats } from "three-blocks/vite/config"; const threeBlocksStats: ThreeBlocksStatsBuildConfig ``` **Purpose:** Declares threeBlocksStats as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksStats. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### threeBlocksText Kind: variable; canonical: https://threejs-blocks.com/docs/api/threeBlocksText. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { threeBlocksText } from "three-blocks/vite/config"; const threeBlocksText: ThreeBlocksTextBuildConfig ``` **Purpose:** Declares threeBlocksText as a public value. It is exported from three-blocks/vite/config. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for threeBlocksText. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite/config entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### transferDeclaredHotState Kind: function; canonical: https://threejs-blocks.com/docs/api/transferDeclaredHotState. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { transferDeclaredHotState } from "three-blocks/hmr"; transferDeclaredHotState(previous: HotScene, candidate: HotScene): void ``` **Purpose:** Transfer compatible own fields while keeping the candidate's declared shape. Renamed, removed, and re-typed fields therefore keep their new-code defaults. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for transferDeclaredHotState. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/hmr entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### transformThreeCodecLoaderUrls Kind: function; canonical: https://threejs-blocks.com/docs/api/transformThreeCodecLoaderUrls. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { transformThreeCodecLoaderUrls } from "three-blocks/vite"; transformThreeCodecLoaderUrls(source: string, options: {readonly threeVersion: string; readonly kind: 'draco' | 'ktx2'; readonly runtimePath: string; readonly id?: string;}): ThreeCodecLoaderTransformResult ``` **Purpose:** Replace Three r185's static addon-relative codec URLs with the one runtime set owned by `threeBlocks()`. Rollup otherwise emits those `new URL(..., import.meta.url)` targets even though application adapters immediately call setDecoderPath()/setTranscoderPath(). **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for transformThreeCodecLoaderUrls. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### transformThreeCoreShaderInputs Kind: function; canonical: https://threejs-blocks.com/docs/api/transformThreeCoreShaderInputs. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { transformThreeCoreShaderInputs } from "three-blocks/vite"; transformThreeCoreShaderInputs(source: string, options: {readonly threeVersion: string; readonly threeRevision?: string; readonly id?: string;}): ThreeProviderHookTransformResult ``` **Purpose:** Retain application-created core textures before lazy TSL setup wraps them in nodes. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for transformThreeCoreShaderInputs. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### transformThreeWebgpuCaptureInstrumentation Kind: function; canonical: https://threejs-blocks.com/docs/api/transformThreeWebgpuCaptureInstrumentation. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { transformThreeWebgpuCaptureInstrumentation } from "three-blocks/vite"; transformThreeWebgpuCaptureInstrumentation(source: string, options?: {readonly runtimeImport?: string; readonly id?: string; readonly forceWebGL?: boolean;}): ThreeCaptureInstrumentationResult ``` **Purpose:** Bootstrap capture and prepare each renderer to use the #34068 debug callback. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for transformThreeWebgpuCaptureInstrumentation. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### transformThreeWebgpuProviderHooks Kind: function; canonical: https://threejs-blocks.com/docs/api/transformThreeWebgpuProviderHooks. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { transformThreeWebgpuProviderHooks } from "three-blocks/vite"; transformThreeWebgpuProviderHooks(source: string, options: {readonly threeVersion: string; readonly threeRevision?: string; readonly id?: string;}): ThreeProviderHookTransformResult ``` **Purpose:** Apply the r185-only upstream backports and compile batching in memory. Each upstream PR is isolated so it can be deleted when a supported Three.js release contains it; exact anchors fail closed on source drift. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for transformThreeWebgpuProviderHooks. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/vite entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### updateSDFBoundsHelper Kind: function; canonical: https://threejs-blocks.com/docs/api/updateSDFBoundsHelper. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { updateSDFBoundsHelper } from "three-blocks/sdf-raymarching"; updateSDFBoundsHelper(helper: Box3Helper, sdfGenerator: SDFVolumeBoundsSource): void ``` **Purpose:** Updates an existing Box3Helper to match current SDF bounds. **Status:** Stable through the curated SDF and raymarching block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for updateSDFBoundsHelper. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/sdf-raymarching. Curated compatibility: WebGPU only renderer; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/sdf-raymarching Direct example imports: https://threejs-blocks.com/examples/webgpu_points_bvh_volume. ### validatePrecompiledManifest Kind: function; canonical: https://threejs-blocks.com/docs/api/validatePrecompiledManifest. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { validatePrecompiledManifest } from "three-blocks/shaders"; validatePrecompiledManifest(value: unknown): ShaderManifestValidation ``` **Purpose:** Declares validatePrecompiledManifest as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/shaders. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for validatePrecompiledManifest. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/shaders entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ### volumeSmokeShadow Kind: function; canonical: https://threejs-blocks.com/docs/api/volumeSmokeShadow. Package version: 0.10.0; Classification: curated-block; Status: stable; Since: Not recorded; Deprecated: No. ```ts import { volumeSmokeShadow } from "three-blocks/smoke"; volumeSmokeShadow({opticalDepthTexture, worldToDomain, lightDirLocal, strength,}: VolumeSmokeShadowOptions): VolumeSmokeShadowNode ``` **Purpose:** Samples a smoke volume's existing directional optical-depth cache as a scene shadow. Rays that miss the domain return one; rays that hit sample the light-facing entry point. **Status:** Stable through the curated Smoke block. No deprecation marker is recorded for this symbol in Three Blocks 0.10.0. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for volumeSmokeShadow. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from three-blocks/smoke. Curated compatibility: WebGPU and WebGL renderers; browser environment. Curated block: https://threejs-blocks.com/docs/blocks/smoke Direct example imports: https://threejs-blocks.com/examples/webgpu_simulation_smoke_3d. ### withTransfer Kind: function; canonical: https://threejs-blocks.com/docs/api/withTransfer. Package version: 0.10.0; Classification: generated-only; Status: Not assigned; Since: Not recorded; Deprecated: No. ```ts import { withTransfer } from "three-blocks/worker"; withTransfer(value: TResult, transfer: readonly object[]): WorkerTransfer ``` **Purpose:** Declares withTransfer as a public function with the parameters and return type shown in its signature. It is exported from three-blocks/worker. No authored product-level summary is present, so this guidance does not infer behavior beyond the declaration. **Status:** Exported by Three Blocks 0.10.0 with no deprecation marker. No curated stability level is assigned to this generated-only symbol. No introduction version is recorded in release history. **Lifecycle:** The public declaration exposes no constructor or recognized lifecycle-shaped method for withTransfer. It does not specify initialization, per-frame update, resize, or disposal requirements. **Compatibility:** Available from the public three-blocks/worker entry point. The public declaration does not specify renderer, browser, worker, or Node.js compatibility; do not infer support from the symbol name. Direct example imports: none recorded. ## Compact index snapshot # Three Blocks > Public integration index generated from the Three Blocks 0.10.0 documentation model. ## AI Usage Policy This documentation is published so AI assistants can help people use the public `three-blocks` API: - Public documentation may be retrieved and summarized to help a person use the documented API. - Documentation permission does not change the PolyForm Noncommercial 1.0.0 license on implementation code. That license and applicable law control use of npm `dist`, examples, and source. - Text-and-data-mining rights are reserved to the extent permitted by law (EU Directive 2019/790 Art. 4(3); see `/ai.txt`, `/.well-known/tdmrep.json`, and the `tdm-reservation` response header). - The accepted commercial agreement separately restricts training or evaluating models on implementation source and proprietary Pro Tools. ## License and Pro boundary - The `three-blocks` runtime, `@three-blocks/devtools`, `create-three-blocks-starter`, and shipped template source use PolyForm Noncommercial 1.0.0. - Personal and noncommercial projects are free. Pro grants each Project started during an active period a lifetime commercial license for versions released during that period. Covered Projects and Pro Tool versions obtained while active may keep running locally and offline after cancellation. New commercial Projects, later versions, and Pro Tool downloads or updates require an active seat. Covered versions have no runtime gate. - New Pro Tool downloads and updates use `npx three-blocks login`; installed covered tools run locally. Public runtime imports, starter creation, and generated application execution do not check an account. ## Install and first render ```bash npm i three-blocks three npx three-blocks doctor ``` Use `three/webgpu`, create `WebGPURenderer`, and await `renderer.init()` before compute or render work. Dispose Three Blocks resources and the renderer when their owner is removed. ## Agent skill One command installs the Three Blocks support-expert skill (generated from this documentation model) into any agent that supports Agent Skills: ```bash npx skills add https://threejs-blocks.com ``` Discovery index: https://threejs-blocks.com/.well-known/agent-skills/index.json. Refresh installed copies with `npx skills add https://threejs-blocks.com`. ## Create paths - [Product visualization](https://threejs-blocks.com/docs/create/product-visualization): Present an object with convincing material, motion, detail, and interaction while keeping payload and runtime costs predictable. - [Interactive experiences](https://threejs-blocks.com/docs/create/interactive-experiences): Make a scene respond to people, layout, motion, and spatial content without turning it into an unmaintainable demo. - [Visual effects](https://threejs-blocks.com/docs/create/visual-effects): Add atmosphere, physical behavior, and an art-directed image without hiding the render pipeline or cost required to ship it. - [Start with the starter](https://threejs-blocks.com/docs/start/starter): Scaffold the recommended worker-rendered project, run it, read its live status, and make the first edit in src/scene.ts. - [Render your first Three Blocks scene](https://threejs-blocks.com/docs/start/first-scene): Add Three Blocks to an existing Three.js project while keeping renderer initialization, the frame loop, and disposal explicit. - [Framework setup](https://threejs-blocks.com/docs/start/frameworks): Place the same renderer lifecycle inside React Three Fiber, Next.js, TresJS, webpack, or a worker-owned app without surrendering GPU ownership. ## Curated blocks - [Transmission](https://threejs-blocks.com/docs/blocks/transmission): Render controllable refractive depth for glass and translucent product surfaces with an explicit quality cost. Status: stable; renderer: webgpu; public symbols: MeshTransmissionDitherAnchor, MeshTransmissionNodeMaterial, MeshTransmissionNodeMaterialOptions, MeshTransmissionRefractionMode, MeshTransmissionViewportBufferNode. - [Baked Motion](https://threejs-blocks.com/docs/blocks/baked-motion): Turn a rendered camera or timeline sequence into an interactive, depth-aware browser presentation. Status: stable; renderer: webgpu; public symbols: BAKED_MOTION_TYPE, BAKED_MOTION_VERSION, BakedMotion, BakedMotionDelivery, BakedMotionDiagnostics, BakedMotionError, BakedMotionErrorCode, BakedMotionFetch, BakedMotionFetchResponse, BakedMotionFrameSample, BakedMotionGeometry, BakedMotionManifest, BakedMotionMaterial, BakedMotionMesh, BakedMotionOptions, BakedMotionParameterValues, BakedMotionParameters, BakedMotionRenderer, BakedMotionResolvedStrategy, BakedMotionRotationParameters, BakedMotionState, BakedMotionStrategy, BakedMotionTiltParameters, BakedMotionTimelineParameters, BakedMotionViewSource, paramToFrame, parseBakedMotionManifest. - [Object Animation Video](https://threejs-blocks.com/docs/blocks/object-animation-video): Replay compact authored transforms for many rigid parts while geometry, materials, lighting, and per-object binding remain live. Status: experimental; renderer: webgpu/webgl; public symbols: OAV_MANIFEST_TYPE, OAV_MANIFEST_VERSION, ObjectAnimationVideo, ObjectAnimationVideoBindOptions, ObjectAnimationVideoBindResult, ObjectAnimationVideoBinding, ObjectAnimationVideoDecodeEvent, ObjectAnimationVideoDiagnostics, ObjectAnimationVideoErrorEvent, ObjectAnimationVideoEventMap, ObjectAnimationVideoFetch, ObjectAnimationVideoFetchResponse, ObjectAnimationVideoFileValue, ObjectAnimationVideoFiles, ObjectAnimationVideoFrameEvent, ObjectAnimationVideoInstanceBinding, ObjectAnimationVideoInstanceMapping, ObjectAnimationVideoInstanceTarget, ObjectAnimationVideoLoadOptions, ObjectAnimationVideoManifest, ObjectAnimationVideoObjectBinding, ObjectAnimationVideoObjectSelector, ObjectAnimationVideoOptions, ObjectAnimationVideoPlaybackOptions, ObjectAnimationVideoUnbindOptions, parseOAVManifest. - [Vertex Animation Video](https://threejs-blocks.com/docs/blocks/vertex-animation-video): Replay stable-topology mesh deformation and optional appearance while material, lighting, and camera response remain live. Status: experimental; renderer: webgpu; public symbols: VAVBase, VAVManifest, VAVMesh, VAVMeshAppearance, VAVMeshDiagnostics, VAVMeshFetch, VAVMeshFetchResponse, VAVMeshFileResolver, VAVMeshFiles, VAVMeshLoadOptions, VAVMeshOptions, VAVNumericalTrack, VAVTrackDecoderManifest, VAVTrackDescriptor, VAVTrackFetch, VAVTrackFetchResponse, VAVTrackStream, VAVTrackStreamOptions, VAV_MANIFEST_TYPE, VAV_MANIFEST_VERSION, parseVAVBase, parseVAVManifest. - [ActiveFrame Video](https://threejs-blocks.com/docs/blocks/active-frame-video): Decode and synchronize compact GPU-ready animation frames with bounded browser-side resources. Status: experimental; renderer: webgpu/webgl; public symbols: ACTIVE_FRAME_TYPE, ACTIVE_FRAME_VERSION, AFDecoder, AFDecoderErrorCallback, AFDecoderOptions, AFDecoderProcess, AFDecoderSource, AFVideo, AFVideoFrameResult, AFVideoNode, AFVideoOptions, AFVideoRGBNode, AFVideoScalarNode, AFVideoSetFramesOptions, AFVideoSource, AFVideoUVNode, ActiveFrameEncodedSource, ActiveFrameFrame, ActiveFrameManifest, ActiveFrameTrackManifest, parseActiveFrameManifest. - [Gaussian Splats](https://threejs-blocks.com/docs/blocks/gaussian-splats): Render and stream captured 3D or animated Gaussian scenes with explicit sorting, memory, and quality controls. Status: stable; renderer: webgpu; public symbols: GaussianSplats, GaussianSplatsAppearanceOptions, GaussianSplatsData, GaussianSplatsGPUTimings, GaussianSplatsHelper, GaussianSplatsLoadOptions, GaussianSplatsLoadTimings, GaussianSplatsLoader, GaussianSplatsLoaderOptions, GaussianSplatsOptions, GaussianSplatsPoints, GaussianSplatsProcessingProgress, GaussianSplatsQuality, GaussianSplatsRenderEvent, GaussianSplatsRenderRecommendation, GaussianSplatsStats, GaussianSplatsStream, GaussianSplatsStreamLODOptions, GaussianSplatsStreamOptions, GaussianSplatsStreamProgressEvent, GaussianSplatsStreamRendererOptions, GaussianSplatsStreamStats, GaussianSplatsWaitOptions, SplatClip, SplatMesh, SplatSequence, gaussianAAFactor, gaussianAlphaUV, gaussianColor, gaussianDepth, gaussianHue, gaussianLuminance, gaussianNormal, gaussianPower, gaussianSH, gaussianSHColor, gaussianUV. - [MSDF Text](https://threejs-blocks.com/docs/blocks/msdf-text): Draw crisp spatial or screen-space text from a pre-baked atlas with predictable runtime cost. Status: stable; renderer: webgpu/webgl; public symbols: BatchedMSDFText, BatchedMSDFTextAddOptions, BatchedMSDFTextLayoutInfo, BatchedMSDFTextLayoutPatch, BatchedMSDFTextOptions, MSDFFont, MSDFGlyph, MSDFText, MSDFTextLayoutInfo, MSDFTextLineInput, MSDFTextOptions, ParseMSDFFontOptions, parseMSDFFont. - [Runtime SDF Text](https://threejs-blocks.com/docs/blocks/runtime-sdf-text): Generate glyph distance fields at runtime when text cannot be known ahead of time, accepting its higher setup and memory cost. Status: experimental; renderer: webgpu/webgl; public symbols: BatchedText, Text, getAtlasesInfo, textDrawId. - [GPU Interaction](https://threejs-blocks.com/docs/blocks/gpu-interaction): Publish pointer, kinematic, and collider state once so multiple GPU systems can respond in the same frame. Status: experimental; renderer: webgpu; public symbols: GPUInteractionCapabilityReport, GPUInteractionGridOptions, GPUInteractionLimitFailure, GPUInteractionPhysicsEngine, GPUInteractionPhysicsOptions, GPUInteractionPhysicsSource, GPUInteractionPhysicsStep, GPUInteractionQueryMode, GPUInteractionRequiredRendererLimits, GPUInteractionSimulation, GPUInteractionSimulationOptions, GPUInteractionSizingReport, GPUInteractionSource, GPUInteractionSourceRange, GPUInteractionStats, GPUInteractionStorageRendererLimits, GPUInteractionSystem, GPUInteractionSystemOptions, GPUInteractionWorld, GPUInteractionWorldOptions, KinematicInteractionShape, KinematicInteractionSource, KinematicInteractionSourceOptions. - [Surface Sampling](https://threejs-blocks.com/docs/blocks/surface-sampling): Populate static, skinned, or GPU-deformed surfaces without reading instance transforms back to the CPU. Status: stable; renderer: webgpu; public symbols: ComputeBVHSampler, ComputeBVHSamplerComputeOptions, ComputeBVHSamplerOptions, ComputeBVHSamplerSource, ComputeBVHSamplerStrategy, ComputeMeshDynamicSurfaceSampler, ComputeMeshDynamicSurfaceSamplerComputeOptions, ComputeMeshDynamicSurfaceSamplerOptions, ComputeMeshDynamicSurfaceSamplerOutputs, ComputeMeshDynamicSurfaceSamplerReadback, ComputeMeshSurfaceSampler, ComputeMeshSurfaceSamplerComputeOptions, ComputeMeshSurfaceSamplerOptions. - [Instance Culling](https://threejs-blocks.com/docs/blocks/instance-culling): Cull large instance sets on the GPU before shading and drawing the visible survivors. Status: stable; renderer: webgpu; public symbols: ComputeInstanceCulling, ComputeInstanceCullingBoundingSphere, ComputeInstanceCullingBoundingSphereResult, ComputeInstanceCullingBoundsData, ComputeInstanceCullingBufferSource, ComputeInstanceCullingCommonOptions, ComputeInstanceCullingMeshOptions, ComputeInstanceCullingOptions, ComputeInstanceCullingStandaloneOptions, ComputeInstanceCullingStorageAttribute, LOD_MODE_EXP, instanceCullingIndex, instanceCullingMatrix. - [Indirect Batching](https://threejs-blocks.com/docs/blocks/indirect-batching): Merge heterogeneous meshes into a GPU-controlled batch and render the visible set with indirect draws. Status: stable; renderer: webgpu; public symbols: IndirectBatchedMesh, IndirectBatchedMeshGeometryId, IndirectBatchedMeshInstanceId, IndirectBatchedMeshMaterial. - [Smoke](https://threejs-blocks.com/docs/blocks/smoke): Build pointer-reactive 2D or volumetric smoke with an explicit simulation and compositing quality ladder. Status: stable; renderer: webgpu/webgl; public symbols: SmokeDomainBindingOptions, SmokeMultigridPreset, SmokeNodePointerInput, SmokeNodeResult, SmokePressureSolver, SmokePressureSolverOptions, SmokeRenderCacheOptions, SmokeSplatBlendMode, SmokeSplatExecutionPath, SmokeSplatMode, SmokeSplatOptions, SmokeSplatStats, SmokeStepOptions, SmokeStepStats, SmokeTurbulenceMode, SmokeVolume, SmokeVolumeOptions, VolumeSmokeNodeMaterial, VolumeSmokeNodeMaterialOptions, VolumeSmokeOutputMode, VolumeSmokeRenderCompositor, VolumeSmokeShaderOptions, VolumeSmokeTextureInput, VolumeSmokeTextureOptions, VolumeSmokeTextureSyncOptions, smoke, smokeRTT, volumeSmokeShadow. - [Water](https://threejs-blocks.com/docs/blocks/water): Simulate and render interactive water from particle volume through surface or raymarched presentation. Status: stable; renderer: webgpu; public symbols: ComputeSphereRasterizer, WATER_RAYMARCH_QUALITY_PRESETS, WaterCaustics, WaterFoamMeshOptions, WaterFoamOptions, WaterMaterialSSROptions, WaterMaterialUniformOptions, WaterNodeMaterial, WaterNodeMaterialOptions, WaterPreset, WaterRayMarchQualityOverrides, WaterRayMarchQualityPreset, WaterRayMarchQualitySettings, WaterRayMarchQualitySnapshot, WaterRayMarchReflectionSteps, WaterRayMarchRenderer, WaterRayMarchRendererOptions, WaterRayMarchScatterSamples, WaterRayMarchTraceOptions, WaterSurfaceCamera, WaterSurfaceFieldOptions, WaterSurfaceFoamMeshOptions, WaterSurfaceRenderer, WaterSurfaceRendererOptions, WaterVolume, WaterVolumeBoundaryMode, WaterVolumeBoundaryOptions, WaterVolumeDomainBindingOptions, WaterVolumeLattice, WaterVolumeMaterialOptions, WaterVolumeOptions, WaterVolumePointerOptions, WaterVolumeSeedOptions, WaterVolumeSolverOptions, WaterVolumeSplashOptions, WaterVolumeStepStats, WaterVolumeWavesOptions, WaterWaveComponentOptions, WaterWaveDirection, createWaterComposite, getWaterRayMarchQualityPreset. - [Material Point Method](https://threejs-blocks.com/docs/blocks/mpm): Build custom particle-grid simulations with explicit material models, forces, seeding, diagnostics, and render mirrors. Status: stable; renderer: webgpu; public symbols: MPMBoundaryOptions, MPMCFLConfiguration, MPMComputeBatch, MPMCoreGraph, MPMCoreKernels, MPMDiagnosticsOptions, MPMDiagnosticsSnapshot, MPMElasticModel, MPMElasticModelOptions, MPMElasticParticleFields, MPMElasticUniforms, MPMFluidModel, MPMFluidModelOptions, MPMFluidUniforms, MPMFormulation, MPMGranularModel, MPMGranularModelOptions, MPMGranularUniforms, MPMGridForce, MPMGridForceContext, MPMIntegrationProfile, MPMMaterialModel, MPMMaterialParticleContext, MPMMaterialStressContext, MPMMaterialUpdateContext, MPMP2GMode, MPMParticleField, MPMParticleFieldMap, MPMParticleFieldType, MPMParticleForce, MPMParticleForceContext, MPMParticleNode, MPMParticleUpdate, MPMParticleUpdateContext, MPMPostPasses, MPMResolvedSortingOptions, MPMSeedContext, MPMSeedInitializer, MPMSeedState, MPMSolver, MPMSolverOptions, MPMSolverUniforms, MPMSortingOptions, MPMStepPostPassContext, MPMStepStats. - [Boids](https://threejs-blocks.com/docs/blocks/boids): Simulate flocking in two or three dimensions with spatial-grid acceleration and optional volume constraints. Status: stable; renderer: webgpu; public symbols: Boids, BoidsInitialPositions, BoidsOptions, SpatialGridHelper, spatialLookupInternals. - [Position-Based Fluids](https://threejs-blocks.com/docs/blocks/pbf): Model interactive incompressible particles with iterative positional constraints and predictable iteration controls. Status: stable; renderer: webgpu; public symbols: PBF, PBFArtificialPressureOptions, PBFCalibrationMode, PBFCalibrationSnapshot, PBFComponents, PBFDiagnosticsOptions, PBFDimension, PBFDomainBindingOptions, PBFDomainOptions, PBFInitialPositions, PBFInitializationMode, PBFInitializationOptions, PBFMaterialOptions, PBFMaterialPreset, PBFMetricSummary, PBFMetrics, PBFNeighborOptions, PBFOptions, PBFParticlesOptions, PBFResetOptions, PBFSolverMaterialOptions, PBFSolverOptions, PBFStats, PBFTimeStepOptions, PBFVectorComponents. - [Smoothed Particle Hydrodynamics](https://threejs-blocks.com/docs/blocks/sph): Model pressure-driven particle fluids when force behavior matters more than PBF-style constraint convergence. Status: stable; renderer: webgpu; public symbols: SPH, SPHCalibrationMode, SPHCalibrationSnapshot, SPHComponents, SPHDiagnosticsOptions, SPHDimension, SPHDomainBindingOptions, SPHDomainOptions, SPHEquationOfState, SPHInitialPositions, SPHInitializationMode, SPHInitializationOptions, SPHMaterialOptions, SPHMaterialPreset, SPHMetricSummary, SPHMetrics, SPHNegativePressurePolicy, SPHNeighborOptions, SPHOptions, SPHParticlesOptions, SPHRendererLimits, SPHResetOptions, SPHSolverMaterialOptions, SPHSolverOptions, SPHStats, SPHTimeStepOptions, SPHTimeStepPolicy, SPHVectorComponents. - [SDF and raymarching](https://threejs-blocks.com/docs/blocks/sdf-raymarching): Build GPU-readable signed-distance fields for constraints, sampling, and raymarched surfaces or volumes — including live per-frame fields rebuilt from skinned characters. Status: stable; renderer: webgpu; public symbols: BVHVolumeConstraint, BVHVolumeConstraintMode, BVHVolumeConstraintOptions, ComputePointsSDFGenerator, ComputeSDFGenerator, RayMarchSDFMaterialOptions, RayMarchSDFNodeMaterial, RaymarchingBox, RenderSDFLayerNodeMaterial, SDFBoundaryApplyOptions, SDFGeneratorOptions, SDFParticleVectorStorage, SDFSliceVolumeNodeMaterial, SDFTextureOutput, SDFVolumeConstraint, SDFVolumeConstraintOptions, SDFVolumeSource, SkinnedMeshSDF, SkinnedMeshSDFCollideOptions, SkinnedMeshSDFOptions, SkinnedMeshSDFSamplePosition, SkinnedMeshSDFScalar, SkinnedMeshSDFUniforms, createSDFBoundsHelper, createSDFPointCloudHelper, updateSDFBoundsHelper. - [Sphere impostors](https://threejs-blocks.com/docs/blocks/sphere-impostors): Shade one-triangle particle impostors as lit spheres when hardware sphere geometry would dominate vertex cost. Status: stable; renderer: webgpu; public symbols: SphereImpostorNodeMaterial, SphereImpostorNodeMaterialParameters, SphereImpostorNormalNodeMaterial, SphereImpostorPositionConfig, SphereImpostorToonNodeMaterial, sphereImpostorAlpha, sphereImpostorDepth, sphereImpostorNormal, sphereImpostorPosition, sphereImpostorShadow, sphereImpostorSurfaceNormal. - [Pristine grid](https://threejs-blocks.com/docs/blocks/grid-pristine): Add an infinite anti-aliased reference grid with two independently styled world-space layers. Status: stable; renderer: webgpu/webgl; public symbols: GridPristine. - [Core TSL effects](https://threejs-blocks.com/docs/blocks/core-tsl-effects): Compose reusable film, painterly, Fresnel, parallax, projection, and noise treatments inside Three.js node materials and post passes. Status: stable; renderer: webgpu/webgl; public symbols: FilmHDOptions, KuwaharaOptions, biplanarTexture, filmHD, fresnel, kuwahara, parallaxOcclusion. - [Compute foundations](https://threejs-blocks.com/docs/blocks/compute-foundations): Use sorting, prefix sums, batching, and GPU-generated geometry as the data-moving foundation for larger blocks. Status: experimental; renderer: webgpu; public symbols: ComputeBitonicSort, ComputeBitonicSortOptions, ComputeFoundationStorage, ComputeFoundationValueType, ComputePrefixSum, ComputePrefixSumOptions, ComputeRadixSort, ComputeRadixSortOptions. ## Authoring tools - [Devtools](https://threejs-blocks.com/docs/tools/devtools): Watch a Three Blocks app while you develop, and prepare shaders, text atlases, environment lighting, and GPU-compressed assets ahead of production. Access: free; outputs: versioned WebGPU shader manifests, live-versus-precompiled parity evidence, development overlay, MSDF atlas, metrics, browser-font copy, and receipt, prefiltered environment KTX2, meshopt + KTX2 optimized GLB, texture, and HDR assets with a freshness receipt; verified against: @three-blocks/devtools 0.1.0. - [Three Blocks CLI](https://threejs-blocks.com/docs/tools/three-blocks-cli): Authenticate, diagnose a project, inspect available tools, and install supported authoring integrations. Access: free; outputs: project diagnostics, authoring-tool installations; verified against: Three Blocks Blender hub 0.3.3. - [Baked Motion Video](https://threejs-blocks.com/docs/tools/baked-motion-video): Convert Blender timeline, tilt-grid, or rotation renders into whole-file ActiveFrame packages. Access: pro-seat; outputs: .utsbv manifest, .af media tracks, depth and albedo data; verified against: Baked Motion Blender addon 1.5.1. - [Object Animation Video exporter](https://threejs-blocks.com/docs/tools/object-animation-video): Encode named rigid-object transforms into exact binary OAV packages. Access: pro-seat; outputs: OAV manifest, UTSBM transform track, machine-readable build report; verified against: Object Animation Video Blender addon 1.0.1. - [Vertex Animation Video exporter](https://threejs-blocks.com/docs/tools/vertex-animation-video): Encode deforming vertex positions, normals, and appearance into exact binary VAV packages. Access: pro-seat; outputs: VAV manifest, UTSBM numerical tracks, optional UV visual media tracks, machine-readable build report; verified against: Vertex Animation Video Blender addon 1.4.1. - [Gaussian splat pipelines](https://threejs-blocks.com/docs/tools/gaussian-splat-pipeline): Capture a Blender still or timeline as a static Gaussian asset or validated 4DGS clip. Access: pro-seat; outputs: .ply, .sids, .sog, .b4dgs, .b4dgs.json; verified against: Mesh to Splat Blender addon 0.2.6. ## Public API All 895 public symbols from 38 package entry points are indexed at https://threejs-blocks.com/docs/api. Exact signatures come from built declaration roots; implementation source is intentionally absent. - `three-blocks`: 17 exported symbols — The curated core barrel: stable block facades and shared types for app code. Platform machinery and experimental work ship on named subpaths, not here. - `three-blocks/msdf-text`: 13 exported symbols — Draw crisp spatial or screen-space text from a pre-baked atlas with predictable runtime cost. - `three-blocks/surface-sampling`: 13 exported symbols — Populate static, skinned, or GPU-deformed surfaces without reading instance transforms back to the CPU. - `three-blocks/instance-culling`: 13 exported symbols — Cull large instance sets on the GPU before shading and drawing the visible survivors. - `three-blocks/indirect-batching`: 4 exported symbols — Merge heterogeneous meshes into a GPU-controlled batch and render the visible set with indirect draws. - `three-blocks/boids`: 5 exported symbols — Simulate flocking in two or three dimensions with spatial-grid acceleration and optional volume constraints. - `three-blocks/pbf`: 25 exported symbols — Model interactive incompressible particles with iterative positional constraints and predictable iteration controls. - `three-blocks/sph`: 28 exported symbols — Model pressure-driven particle fluids when force behavior matters more than PBF-style constraint convergence. - `three-blocks/mpm`: 45 exported symbols — Build custom particle-grid simulations with explicit material models, forces, seeding, diagnostics, and render mirrors. - `three-blocks/sphere-impostors`: 11 exported symbols — Shade one-triangle particle impostors as lit spheres when hardware sphere geometry would dominate vertex cost. - `three-blocks/grid-pristine`: 1 exported symbols — Add an infinite anti-aliased reference grid with two independently styled world-space layers. - `three-blocks/core-tsl-effects`: 7 exported symbols — Compose reusable film, painterly, Fresnel, parallax, projection, and noise treatments inside Three.js node materials and post passes. - `three-blocks/transmission`: 5 exported symbols — Render controllable refractive depth for glass and translucent product surfaces with an explicit quality cost. - `three-blocks/baked-motion`: 27 exported symbols — Turn a rendered camera or timeline sequence into an interactive, depth-aware browser presentation. - `three-blocks/experimental/object-animation-video`: 26 exported symbols — Replay compact authored transforms for many rigid parts while geometry, materials, lighting, and per-object binding remain live. - `three-blocks/experimental/vertex-animation-video`: 22 exported symbols — Replay stable-topology mesh deformation and optional appearance while material, lighting, and camera response remain live. - `three-blocks/experimental/active-frame-video`: 21 exported symbols — Decode and synchronize compact GPU-ready animation frames with bounded browser-side resources. - `three-blocks/gaussian-splats`: 37 exported symbols — Render and stream captured 3D or animated Gaussian scenes with explicit sorting, memory, and quality controls. - `three-blocks/experimental/gpu-interaction`: 23 exported symbols — Publish pointer, kinematic, and collider state once so multiple GPU systems can respond in the same frame. - `three-blocks/smoke`: 28 exported symbols — Build pointer-reactive 2D or volumetric smoke with an explicit simulation and compositing quality ladder. - `three-blocks/water`: 41 exported symbols — Simulate and render interactive water from particle volume through surface or raymarched presentation. - `three-blocks/sdf-raymarching`: 26 exported symbols — Build GPU-readable signed-distance fields for constraints, sampling, and raymarched surfaces or volumes — including live per-frame fields rebuilt from skinned characters. - `three-blocks/experimental/compute-foundations`: 8 exported symbols — Use sorting, prefix sums, batching, and GPU-generated geometry as the data-moving foundation for larger blocks. - `three-blocks/experimental/runtime-sdf-text`: 4 exported symbols — Generate glyph distance fields at runtime when text cannot be known ahead of time, accepting its higher setup and memory cost. - `three-blocks/experimental/core-tsl-effects`: 3 exported symbols — Experimental TSL effect nodes staged before promotion to the stable block. - `three-blocks/assets`: 86 exported symbols — Typed asset manager with adapter registry, scoped leases, retry/concurrency control, and the standard three.js loader adapters (GLTF, KTX2, DRACO, HDR, fonts). - `three-blocks/app`: 56 exported symbols — Application shell for worker-owned renderers: WorkerHost restart choreography, input forwarding, status + smoke bridges, and worker-side runtime assembly. Scaffolded starter apps stand on it. - `three-blocks/devtools`: 10 exported symbols — Runtime devtools registration and overlay mount for apps that do not use the app shell; publishes renderer status and performance evidence to the dev overlay. - `three-blocks/hmr`: 21 exported symbols — Hot-replacement primitives for scenes and components: snapshot capture/restore and a scene hot reloader with compile-before-commit swaps. - `three-blocks/runtime`: 15 exported symbols — Frame dispatcher with rAF and fixed-step lanes, render priorities, and typed event triggers — the per-frame backbone used inside render workers. - `three-blocks/shaders`: 91 exported symbols — Precompiled-shader manifest tooling and the runtime shader cache: capture, validate, hydrate, and observe TSL node builds on three r185 WebGPU. - `three-blocks/stats`: 17 exported symbols — Main/worker performance-stats adapters (CPU/GPU timings, texture panels) feeding the dev overlay and the app shell's stats controllers. - `three-blocks/text`: 36 exported symbols — Shared text-runtime contracts: configuration, sync batch/delivery types, font sources, and schema guards used on both sides of the worker boundary. - `three-blocks/text/main`: 5 exported symbols — Page-side text sync: observes DOM text and publishes layout and content deliveries to the worker text renderer. - `three-blocks/text/worker`: 11 exported symbols — Worker-side text renderer: loads fonts, builds text batches, and applies page deliveries inside the render worker. - `three-blocks/vite`: 59 exported symbols — The Vite plugin: shader precompile capture, codec and asset wiring, dev status overlay, build receipts, and project inspection. - `three-blocks/vite/config`: 32 exported symbols — Type declarations for the plugin-injected virtual client config (`threeBlocksConfig`, codec runtimes, build receipts). - `three-blocks/worker`: 44 exported symbols — Typed main↔worker transport with state, event, and RPC lanes, compile-time structured-clone checking, transferables, and endpoint replacement for restarts. Knows nothing about three.js. ## Agent rules - Prefer a curated block contract before an isolated low-level helper. - Use the import path shown on the generated symbol page; do not guess deep source paths. - Preserve lifecycle order: initialize, update/compute, render, resize, dispose. - Link users to the canonical human page for selection guidance, examples, compatibility, and production notes. - Never expose credentials in source or `.npmrc`; use `npx three-blocks login` and `npx three-blocks doctor`. Detailed generated reference: https://threejs-blocks.com/llms-full.txt