ocean
The oceans package's substrate. One `Ocean.create` call brings up a live sea: the GPU wave simulation, the surface mesh that renders it, the material bound to the simulation's output, and the body of water physics reads.
ocean
The oceans package's substrate. One Ocean.create call brings up a live sea: the
GPU wave simulation, the surface mesh that renders it, the material bound to the
simulation's output, and the body of water physics reads.
The simulation is spectral and runs in cascades: independent wave fields over different patch sizes, each band-limited to its own range of wavelengths, summed into one surface. That is what gives detail at every scale (swell, wind waves, chop) while keeping each transform small.
The surface is one mesh whose vertices a compute pass rewrites every frame, so no wave data crosses to the CPU for rendering. It is graded radially and follows the viewer, snapped to a wave-patch multiple so the sea stays put in the world while the mesh slides under it.
sampleHeight / sampleDisplacement answer where the water is from the sea's
physics band: the cascades' waves of at least physicsWavelength metres and the
swell, defined as a body of water (Physics.water reads it as
ocean.waterName) and evaluated on the CPU at the water clock's moment, which
every peer shares. The drawn surface is that band plus the shorter chop, drawn
from the same amplitudes; physicsBand states the difference and
measureAgreement measures it. Both invert the horizontal wave displacement, so
they return the surface point that actually ended up above the position you
asked about.
Use the Ocean component to place a sea in a scene; use this module directly to
drive one from code.
Interface
What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.
conforms to
zero/source-extract/v2Spectral ocean simulation and surface. Creates a live sea from a named sea state, renders it, and answers where its surface is.
spectrum( ) → void
evolve( ) → void
fft( ) → void
assemble( ) → void
normals( ) → void
displace( ) → void
probe( ) → void
foam( ) → void
foam_texture( ) → void
gpu(name: string) → any
| arg | type | description |
|---|---|---|
| name | string |
sweepUnownedSurfaces( ) → void
Retire every ocean surface in the scene that no live instance owns. Ownership is asked of THIS copy's registry, so after a reload that is every surface the previous copies left: exactly the ones nothing can reach to stop. Despawning the surface is also what the orphan itself notices, `_step` reads it and tears the whole instance down, handing back its buffers, its maps and its session material, so the sweep ends the simulation, not just the draw.
merge(base: any, over: any) → any
Deep merge: `over` wins leaf by leaf, so naming a preset and then setting one nested field overrides only that field. Arrays are merged by index for the same reason, `cascades = { { scale = 2000 } }` should retouch the first cascade rather than replace the pair.
| arg | type | description |
|---|---|---|
| base | any | |
| over | any |
spreadIntegral(exponent: number, backRatio: number) → number
Integral of the directional spreading function over [0, 2pi), as a 64-band midpoint sum.
| arg | type | description |
|---|---|---|
| exponent | number | |
| backRatio | number |
assignBands(cascades: { any }, waves: any) → void
Give each cascade a disjoint slice of wave-number space. Crossovers sit at the geometric mean of one cascade's Nyquist and the next one's fundamental, and each band is rescaled by `sqrt(total / band)` so that splitting the spectrum does not change the energy any one cascade carries. Without this the cascades synthesise the same long waves twice and neither produces the short ones.
| arg | type | description |
|---|---|---|
| cascades | { any } | |
| waves | any |
resolveSwell(gerstner: any, waves: any, count: number) → void
Resolve the Gerstner configuration into the per-band values both the GPU passes and the CPU sampler read. Three factors here are not obvious and each changes the swell visibly: the amplitude carries a `windSpeed / 10` term, so the same swell settings raise a bigger sea in a gale; steepness is simply `min(0.5 * choppiness, 1)` rather than anything derived from the wave number; and total energy is held constant across band counts by `1 / sqrt(n)`, so a higher quality tier resolves the same swell more finely instead of raising a larger one.
| arg | type | description |
|---|---|---|
| gerstner | any | |
| waves | any | |
| count | number |
viewerPosition( ) → void
The world position the surface centres on. The ON-SCREEN camera is the right one to follow: in edit mode that is the author's fly camera, so the sea stays under whoever is looking at it.
cameraPlanes( ) → void
mul32(a: number, b: number) → number
| arg | type | description |
|---|---|---|
| a | number | |
| b | number |
hash32(v: number) → number
| arg | type | description |
|---|---|---|
| v | number |
unit(h: number) → number
A hash as a uniform number strictly inside (0, 1).
| arg | type | description |
|---|---|---|
| h | number |
smoothstep(a: number, b: number, x: number) → number
| arg | type | description |
|---|---|---|
| a | number | |
| b | number | |
| x | number |
shapedAt(c: any, w: any, ix: number, iz: number) → number
The spectrum's energy at one cell of a cascade, exactly as `ocean_spectrum` shapes it: the `shaped` value before the random draw.
| arg | type | description |
|---|---|---|
| c | any | |
| w | any | |
| ix | number | |
| iz | number |
h0At(c: any, w: any, seed: number, ix: number, iz: number) → void
The cell's drawn amplitude h0, as `ocean_spectrum` draws it: the shaped energy times a complex Gaussian made from the cell's hash.
| arg | type | description |
|---|---|---|
| c | any | |
| w | any | |
| seed | number | |
| ix | number | |
| iz | number |
quantaTable(c: any, gravity: number) → void
Each squared wave number's angular frequency in whole quanta `2pi / LOOP_PERIOD`, the deep-water `sqrt(g k)` rounded to the nearest: index `jx^2 + jz^2 + 1` holds the cell `(jx, jz)` of a cascade's grid. Worked out once, here, so the evolve pass draws each wave at exactly the frequency the physics band evaluates it at; rounding the same number on the device and here would part them wherever it falls near a half.
| arg | type | description |
|---|---|---|
| c | any | |
| gravity | number |
_resolveCascades(self: ?) → void
Which cascades actually run, pairing the preset's bands with the tier's resolutions BY INDEX. A band the tier switched off is dropped without shifting the others, or band 1 would inherit band 0's scale and amplitude.
| arg | type | description |
|---|---|---|
| self | ? |
_packCascade(self: ?, c: any, slot: number) → void
| arg | type | description |
|---|---|---|
| self | ? | |
| c | any | |
| slot | number |
_allocate(self: ?) → void
Every buffer the pipeline runs on. Each is created on the shader that writes it first, and every later pass is handed that same handle, so what a stage reads is the thing an earlier stage was given, stated in the dispatch rather than agreed on through a name.
| arg | type | description |
|---|---|---|
| self | ? |
_seedSpectrum(self: ?) → void
Rebuild the static spectrum and the swell bank. Runs on creation and whenever the sea state changes, never per frame.
| arg | type | description |
|---|---|---|
| self | ? |
_writeSwell(self: ?, t: number) → void
| arg | type | description |
|---|---|---|
| self | ? | |
| t | number |
_buildMesh(self: ?) → void
| arg | type | description |
|---|---|---|
| self | ? |
_attach(self: ?, target: any) → void
| arg | type | description |
|---|---|---|
| self | ? | |
| target | any |
_ensureMaterial(self: ?) → void
Build the session material and bind everything to it. The ocean drives cascade maps, sampling tiles and the scene capture on its material every frame. Those are properties of THIS sea, not of the material asset, and writing them to the asset would persist per-frame state into content. So the entity renders a SESSION material: a runtime copy of the authored look, live for this engine session only. It is built on the first STEP rather than at attach, and that ordering is load-bearing. At attach the surface shader has not compiled, so the material is created against a pipeline that does not exist; the one that replaces it when the shader lands does not inherit the binding, and the mesh then draws with no material data at all, black, whatever the shader computes. Setting the properties again later does not rescue it either, because it is the material object itself that was built too early. By the first step the shader has landed and every compute map has been filled, which is the first moment this can stick.
| arg | type | description |
|---|---|---|
| self | ? |
_bindMaterial(self: ?) → void
Push everything the material cannot know on its own.
| arg | type | description |
|---|---|---|
| self | ? |
foamLayer(prefix: string, layer: any) → void
| arg | type | description |
|---|---|---|
| prefix | string | |
| layer | any |
_bindSimulationTextures(self: ?) → void
Bind the maps the simulation writes. These are compute textures, and a compute texture does not exist until the pass that fills it has run. Naming one before then binds a slot to nothing, which invalidates the whole bind group, the surface then draws with no material data at all and comes out black, whatever the shader computes. So the binding waits for the first frame's `copyBufferToTexture` and latches.
| arg | type | description |
|---|---|---|
| self | ? |
_bindUnderwater(self: ?) → void
| arg | type | description |
|---|---|---|
| self | ? |
_pushUnderwater(self: ?) → void
The sea state the underwater pass draws with. It renders the SAME water the surface does, from beneath it, off the same colours, the same caustics and the same sea level, so the push runs again whenever the configuration moves, and a sea recoloured mid-session looks the same from under it as it does from above.
| arg | type | description |
|---|---|---|
| self | ? |
_stepUnderwater(self: ?) → void
| arg | type | description |
|---|---|---|
| self | ? |
_stepUnderside(self: ?) → void
The surface's own half of the view from below, for a sea whose screen pass belongs to someone else: only the material flips to its Snell's-window underside as the camera crosses the surface.
| arg | type | description |
|---|---|---|
| self | ? |
_buildFoamPatterns(self: ?) → void
Allocate the three foam patterns and write their first frame. Each is its own texture with its own seed, so the layers do not print the same shapes at three different scales. The patterns are LIVING fields - `_stepFoamPatterns` re-dispatches them every frame with the simulation clock, so the maps churn instead of standing as shapes stamped on the sea.
| arg | type | description |
|---|---|---|
| self | ? |
_stepFoamPatterns(self: ?, elapsed: number) → void
| arg | type | description |
|---|---|---|
| self | ? | |
| elapsed | number |
_bindScene(self: ?) → void
The surface reads the scene behind it through the engine's own `zero::scene_color` / `zero::scene_depth` (as the built-in `oceans` package does), so there is no capture to bind: this only switches the depth-driven terms on once the material exists.
| arg | type | description |
|---|---|---|
| self | ? |
isEntityId(s: string) → boolean
One entity however the caller holds it: an entityRef field value ({ __id }), a proxy, an id, or a name.
| arg | type | description |
|---|---|---|
| s | string |
resolveEntity(named: any) → any
| arg | type | description |
|---|---|---|
| named | any |
_bakeGround(self: ?) → void
Fill the ground grid over the region `config.ground` describes. The config only draws the RECT, an entity's footprint, the union of several, or an explicit `{ x, z, size }`, and the heights come from downward raycasts against the physics scene, so the ground the waves meet is EVERYTHING solid standing in the region at once: a landscape, a modelled seabed, a dock, a scatter of rocks. Dynamic bodies are skipped, a moored hull floats ON the waves and must not carve a shadow into them, and so is the sea's own entity. Sampling is chunked across frames; a sixty-thousand-ray gulp would stall the frame that spawned the sea. The grid serves two readers with one truth: the GPU buffer the displace pass shoals by, and the Luau-side table `sampleHeight` applies the same shoaling from.
| arg | type | description |
|---|---|---|
| self | ? |
resolveRegion( ) → void
The region: explicit rect, one entity's footprint, or a union of them. Resolved INSIDE the bake task, because an entity fresh out of a world load exists frames before its bounds do, the bake waits for them rather than killing the attach that asked for it.
grow(b: any) → void
| arg | type | description |
|---|---|---|
| b | any |
isGround(id: string) → boolean
| arg | type | description |
|---|---|---|
| id | string |
heightUnder(x: number, z: number) → number
| arg | type | description |
|---|---|---|
| x | number | |
| z | number |
_groundHeightAt(self: ?, x: number, z: number) → number
The ground's world height under an XZ point, from the baked grid, the CPU half of the same bilinear read the displace pass does.
| arg | type | description |
|---|---|---|
| self | ? | |
| x | number | |
| z | number |
_shoalAt(self: ?, x: number, z: number) → number
The CPU half of the displace pass's shoaling ramp, over the same grid.
| arg | type | description |
|---|---|---|
| self | ? | |
| x | number | |
| z | number |
_settled(self: ?) → boolean
Whether the sea has finished coming up: its material is built and its simulation textures bound, every cascade's displacement is resident (so the displace pass has written the surface), and its seabed holds the wave field. Until then every frame steps, on the clock, whatever the engine's run state.
| arg | type | description |
|---|---|---|
| self | ? |
viewerPoint( ) → void
step(self: ?) → void
Advance the simulation to the water clock's now (`Physics.waterTime`), the moment every peer shares. A SEA NOTHING MOVES COSTS NOTHING (from the built-in `oceans` package): a step evolves the waves only when the moment drawn changes, re-places the surface only when the viewer moves, and a step on which neither moved and nothing was reconfigured dispatches nothing. While the engine is paused (`engine.paused`) a sea that has come up holds the moment it last drew, so a paused editor's water stands still and joins the shared moment again the frame the engine runs. Two drivers call it: the loop `attach` spawns and the Ocean component's update; a sea takes at most one step a frame. Calling it on a destroyed ocean is a no-op.
| arg | type | description |
|---|---|---|
| self | ? |
examples
ocean:step()
_step(self: ?, rawElapsed: number, dt: number, timeMoved: boolean?) → void
| arg | type | description |
|---|---|---|
| self | ? | |
| rawElapsed | number | |
| dt | number | |
| timeMoved | boolean? |
_stepFoam(self: ?, dt: number) → void
Advance the persistent whitecap field. Its region follows the viewer, snapped to a whole texel so the previous frame can be reprojected by an exact offset.
| arg | type | description |
|---|---|---|
| self | ? | |
| dt | number |
_physicsLattices(self: ?) → void
The physics band's lattices: one per cascade, every wave of it at least the sea's physics wavelength long, with the complex amplitude, frequency and chop the GPU evolves it with. See `Physics.defineWater` for the lattice form. Per pair of cells (k, -k) the GPU's evolve stage rotates h0(k) and conj(h0(-k)) by the same angle, its sine part attenuated by the standing-wave ratio; that splits into a part travelling along k and a part against it. The height the assemble stage writes is minus the band amplitude times the field, shifted by (-1)^(jx + jz) for the half-cell the sampler places cell k at.
| arg | type | description |
|---|---|---|
| self | ? |
_defineWater(self: ?) → void
Define the sea as the body of water physics reads, or define it again after the sea, its level or its ground changed.
| arg | type | description |
|---|---|---|
| self | ? |
physicsBand(self: ?) → any
What the sea's physics band carries: the waves `Physics.water`, `sampleHeight` and the physics step read, which are drawn exactly as the CPU evaluates them. The surface drawn adds the cascades' waves shorter than the band, so the drawn height differs from the height read by `residualRms` (metres, the RMS of the waves left out, from the spectrum), and nine points in ten of the drawn surface stand within twice it (`measureAgreement`'s `p90`). Where a crest folds over, the drawn sheet overhangs the point read and the two part by up to the crest's height: a few points in thousands on a whitecapped sea.
| arg | type | description |
|---|---|---|
| self | ? |
examples
local band = ocean:physicsBand(); print(band.residualRms)
probeAt(self: any, data: { number }, x: number, z: number) → void
The device's probe grid at a world XZ point, bilinear, from a snapshot `readDrawnSurface` took: the cascades summed at full resolution, tiling over the largest cascade's sampling tile.
| arg | type | description |
|---|---|---|
| self | any | |
| data | { number } | |
| x | number | |
| z | number |
cell(cx: number, cz: number) → void
| arg | type | description |
|---|---|---|
| cx | number | |
| cz | number |
lerp(a: number, b: number, t: number) → number
| arg | type | description |
|---|---|---|
| a | number | |
| b | number | |
| t | number |
_swellAt(self: ?, x: number, z: number, t: number) → void
The swell's displacement at a rest point at wave time `t`, exactly as the displace pass evaluates it.
| arg | type | description |
|---|---|---|
| self | ? | |
| x | number | |
| z | number | |
| t | number |
readDrawnSurface(self: ?) → any
Read the surface the device drew back once: the cascades summed on a 64 x 64 grid over the largest cascade's tile, as the sea's next step draws it, at that step's moment. Yields until the read lands, so call it from a task. (displacement X, Y, Z, folding), `moment` the water-clock moment drawn, `waveTime` the sea's own time then.
| arg | type | description |
|---|---|---|
| self | ? |
examples
local drawn = ocean:readDrawnSurface()
drawnHeight(self: ?, drawn: any, x: number, z: number) → number
The height the device drew at a world XZ point, from a snapshot `readDrawnSurface` took: the cascades on its grid and the swell, shoaled by the ground, with the choppiness undone by three fixed-point passes.
| arg | type | description |
|---|---|---|
| self | ? | |
| drawn | any | A snapshot from `readDrawnSurface`. |
| x | number | World X. |
| z | number | World Z. |
examples
local y = ocean:drawnHeight(ocean:readDrawnSurface(), 10, -4)
measureAgreement(self: ?) → any
How closely the surface the device draws matches the one physics reads (`Physics.water`, `sampleHeight`): the drawn surface is read back once (`readDrawnSurface`), and at each of its 4096 grid points the height drawn is compared with the body's height at the point and moment it was drawn at. Yields until the read lands. the differences in metres (`p50`, `p90` and `p99` the sizes half, nine in ten and 99 in 100 of the points stand within, which a few folded crests leave where they are while they move `rms` and `max`), how many points were compared, the moment, and the RMS the physics band states for the waves it leaves out (`physicsBand`).
| arg | type | description |
|---|---|---|
| self | ? |
examples
local agreement = ocean:measureAgreement(); print(agreement.rms, agreement.residualRms)
within(share: number) → number
| arg | type | description |
|---|---|---|
| share | number |
sampleDisplacement(self: ?, x: number, z: number) →
The full displacement of the water surface at a world XZ position: the sea's physics band (`physicsBand`) as `Physics.water` reads this sea at the water clock's now. surface standing over this position from its rest, and the height of the surface there.
| arg | type | description |
|---|---|---|
| self | ? | |
| x | number | World X. |
| z | number | World Z. |
examples
local d = ocean:sampleDisplacement(hull.x, hull.z)
sampleHeight(self: ?, x: number, z: number) → number
The height of the water surface at a world XZ position: the sea's physics band as `Physics.water` reads it, the surface a body floats on.
| arg | type | description |
|---|---|---|
| self | ? | |
| x | number | World X. |
| z | number | World Z. |
examples
boat.position = { x, ocean:sampleHeight(x, z), z }configure(self: ?, options: any) → void
Change the sea. Any field of the configuration may be passed; anything omitted is left alone. Naming a preset re-applies that whole sea, with fields passed alongside it still winning.
| arg | type | description |
|---|---|---|
| self | ? | |
| options | any | Fields to change. |
examples
ocean:configure { preset = "gale", waves = { windDirection = 1.2 } }getConfig(self: ?) → any
The sea state this ocean is running, as a table.
| arg | type | description |
|---|---|---|
| self | ? |
examples
local wind = ocean:getConfig().waves.windSpeed
getEntity(self: ?) → any
The entity the surface renders on.
| arg | type | description |
|---|---|---|
| self | ? |
examples
local e = ocean:getEntity()
release(self: ?, what: string, free: () → void
One step of a teardown, held to the step it is. A release that runs into something says so in the log and the teardown carries on, so a single resource the engine will not take back costs its own line rather than the rest of the sea.
| arg | type | description |
|---|---|---|
| self | ? | |
| what | string | |
| free | ( |
_textureKeys(self: ?) → void
Every compute texture key this ocean holds a map under. A compute texture comes into being on the first `copyBufferToTexture` into its key and is owned by that key rather than by a handle, so the release is by name, and these names are the ocean's own, composed from its prefix. One list answers both what the sea allocated and what its teardown hands back, so the two cannot drift apart. It is the NAMES that answer, not the cascade count: `configure` re-resolves the cascades from the tier it is handed, so a sea that came up at three and was turned down to one is still holding the maps the other two wrote. Every key here carries this sea's own prefix, and handing back one nothing is filed under costs a name.
| arg | type | description |
|---|---|---|
| self | ? |
destroy(self: ?) → void
Tear the ocean down: the mesh, every GPU buffer and compute texture it owns, and the entity if this ocean spawned one. An ocean attached to an entity the caller supplied leaves that entity in place. The ocean stops simulating and leaves the registry first, so the teardown completes whether or not the entity it rendered on is still there, and a second call is a no-op.
| arg | type | description |
|---|---|---|
| self | ? |
examples
ocean:destroy()
attach(target: any, options: any?) → any
Bring up an ocean on an entity: the wave simulation, the clipmap surface that renders it, the material bound to the simulation, and the readback gameplay queries. One entity carries one sea, so an entity already carrying one has that sea torn down as this one takes its place; the entity itself stays, whichever sea spawned it. preset. Every block of the configuration may be overridden field by field. `getConfig`, `getEntity` and `destroy`.
| arg | type | description |
|---|---|---|
| target | any | The entity to render the surface on, or nil to spawn one. |
| options | any? | `{ preset, quality, seaLevel, followCamera, ... }` layered over the |
examples
local ocean = Ocean.attach(nil, { preset = "gale", quality = "high" })create(options: any?) → any
Spawn an entity carrying the `Ocean` component, which brings the sea up. The component owns the surface, so the sea survives a scene reload: the simulation and its GPU mesh are rebuilt from the component's own settings. `Ocean.forEntity(e.id)`.
| arg | type | description |
|---|---|---|
| options | any? | Sea state and surface settings. |
examples
local e = Ocean.create({ preset = "gale" })forEntity(entityId: string) → any
The ocean rendering on an entity.
| arg | type | description |
|---|---|---|
| entityId | string | The entity's id. |
examples
local ocean = Ocean.forEntity(e.id)
list( ) →
Every live ocean.
examples
for _, o in ipairs(Ocean.list()) do o:destroy() end
clear( ) → void
Tear down every live ocean.
examples
Ocean.clear()
xz(p: any) →
The named sea states this package ships.
| arg | type | description |
|---|---|---|
| p | any |
examples
for _, name in ipairs(Ocean.presets()) do print(name) end
stampFoam(a: any, b: any, c: any, d: any, e: number?, f: number?) → void
Leave foam on every sea under a stroke: a capsule from one point to another, `radius` metres wide either side, `amount` 0..1 of a full crust. The foam rides its own layer of the persistent foam field, fading over each sea's `wakeSeconds` (14 s unless the sea names its own) and fraying as it ages, so a hull calling this every frame from last frame's stern to this frame's draws a wake that trails behind it. Local to this peer: every peer stamps from its own copy of the hull's replicated transform. Takes points as `{ x, y, z }`, `{ x =, z = }` or vectors, or the six numbers `(x0, z0, x1, z1, radius, amount)`.
| arg | type | description |
|---|---|---|
| a | any | |
| b | any | |
| c | any | |
| d | any | |
| e | number? | |
| f | number? |
examples
Ocean.stampFoam(lastStern, stern, 3.0, 0.6)
stampFoamAt(x: number, z: number, radius: number?, amount: number?) → void
The single-point form of `stampFoam`: a disc of foam.
| arg | type | description |
|---|---|---|
| x | number | |
| z | number | |
| radius | number? | |
| amount | number? |
examples
Ocean.stampFoamAt(10, -4, 2.5, 0.8)
stampFoam(_self: ?, a: any, b: any, c: any, d: any, e: number?, f: number?) → void
`Ocean.stampFoam` on a handle (every sea under the stroke takes it).
| arg | type | description |
|---|---|---|
| _self | ? | |
| a | any | |
| b | any | |
| c | any | |
| d | any | |
| e | number? | |
| f | number? |
setLook(self: ?, params: any?) → void
Draw this sea in a Tidewater look: a table of `look_*` shader parameters (`Looks.params(name)`); nil returns it to realistic. The simulation is untouched; only the surface shader's stylisation changes.
| arg | type | description |
|---|---|---|
| self | ? | |
| params | any? |
examples
ocean:setLook(require("~.modules.looks").params("cartoon"))_pushLook(self: ?) → void
| arg | type | description |
|---|---|---|
| self | ? |
_crestHeight(self: ?) → number
The swell's typical crest height above still water, metres: 1.4 x the RMS of the sea's own physics surface over a few hundred metres, measured once per configuration. What the shader's crest glow and trough shade scale by.
| arg | type | description |
|---|---|---|
| self | ? |
instances( ) → void
Every sea standing now, in creation order (the kind and tests read it).
presets( ) → void
qualities( ) →
The quality tiers this package ships.
examples
for _, name in ipairs(Ocean.qualities()) do print(name) end
oceanWaterKernel( ) → string
run(binding: string, access: string) → any
| arg | type | description |
|---|---|---|
| binding | string | |
| access | string |
seas( ) → void
The seas standing now, in the order they were made.
version( ) → void
A sea moves every frame, so what it is now names its time.
stand(request: any) → void
| arg | type | description |
|---|---|---|
| request | any |
Sub-parts
Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.
Showing up to 3 levels deep. Open a part to see what it holds further down.
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
agent_score is exposed.+ quality × 0.35
+ performance × 0.25
± compat factor
Usability ratings
Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".
Scoped to this part · feeds back into the world's score.