/**
 * Implicit (Gauss-Seidel-like) Jacobi diffusion on a 3D cell-centered scalar grid.
 *
 * Solves the implicit diffusion equation `(I - a*L) x = x0` for `x`, where L is the
 * discrete Laplacian. Solving implicitly is unconditionally stable for any `a >= 0`,
 * which is why Stam's "Stable Fluids" uses it instead of an explicit step.
 *
 * Each iteration writes into a scratch buffer and swaps; after `iterations` rounds the
 * final result is copied into `output`. Increasing `iterations` increases accuracy at
 * linear cost; 4-20 is the usual range. Boundary cells use Neumann (reflective)
 * conditions — missing neighbours are treated as equal to the cell itself, which
 * reduces the effective denominator.
 *
 * Solid cells (marked non-zero in `solid`) are skipped: their value in `output` is
 * left at the corresponding `x0` value.
 *
 * @param {Float32Array} output      Destination (size = res_x * res_y * res_z). Mutated.
 * @param {Float32Array} x0          Source values to diffuse. NOT mutated.
 * @param {Float32Array} scratch     Same size as output; used for ping-pong. Mutated.
 * @param {number} res_x
 * @param {number} res_y
 * @param {number} res_z
 * @param {number} a                 Implicit diffusion coefficient (= dt * diffusion_rate).
 * @param {number} iterations        Jacobi iteration count.
 * @param {Uint8Array} solid         Required cell flags (zero-filled for a wall-free
 *                                   domain); non-zero cells are not updated.
 */
export function v3_grid_apply_diffusion(output: Float32Array, x0: Float32Array, scratch: Float32Array, res_x: number, res_y: number, res_z: number, a: number, iterations: number, solid: Uint8Array): void;
//# sourceMappingURL=v3_grid_apply_diffusion.d.ts.map