incanto 0.19.0 → 0.21.0

package/dist/3d.d.ts

@@ -1541,6 +1541,230 @@ declare class Particles3D extends Node3D {
   private syncParticles;
 }
 //#endregion
+//#region src/3d/water/river.d.ts
+/**
+* River centerline math — the CPU half of {@link River3D}.
+*
+* Everything here works in the river node's LOCAL frame (the caller hands in a
+* `bedAt(x, z)` sampler that has already been shifted into it), so this module
+* imports nothing from three and stays testable in plain node.
+*
+* The shape of a river is NOT authored: it is derived. A path of control
+* points and a width profile is all a scene declares; the ground underneath
+* decides the rest —
+*
+* - the **surface profile** follows the bed's descending envelope, so the water
+*   runs downhill and never climbs (a rising bed dams it into a still pool);
+* - the **visible width** is whatever the terrain lets the water occupy: every
+*   vertex carries its own water column (`surfaceY − bed`), the shader fades to
+*   nothing where that reaches zero, so banks, gravel bars and half-drowned
+*   boulders carve the ribbon instead of a hand-authored outline;
+* - the **current** obeys continuity (narrow = fast) and grade (steep = fast),
+*   which is what makes rapids sit where a channel pinches or tips.
+*/
+/** Terrain height under a LOCAL-frame point, in the same frame's meters. */
+type BedSampler = (x: number, z: number) => number;
+/** One arc-length sample of the smoothed centerline. */
+interface PathSample {
+  x: number;
+  z: number;
+  /** Unit tangent, pointing downstream. */
+  tx: number;
+  tz: number;
+  /** Meters from the source. */
+  along: number;
+}
+/** A cross-section station: where the water is, how wide, how fast. */
+interface RiverRing extends PathSample {
+  halfWidth: number;
+  /** Water surface height (local Y). */
+  surfaceY: number;
+  /** Downhill grade of the surface (dimensionless, ≥ 0). */
+  slope: number;
+  /** Surface current in m/s. */
+  speed: number;
+}
+interface RiverHit {
+  /** In the channel: inside the banks AND between source and mouth. */
+  inside: boolean;
+  /** Signed offset from the centerline in half-widths (±1 = the banks). */
+  across: number;
+  /** Meters downstream from the source. */
+  along: number;
+  surfaceY: number;
+  /** Unit downstream direction at the projection. */
+  dirX: number;
+  dirZ: number;
+  speed: number;
+  halfWidth: number;
+}
+/** A place where the river stops flowing and starts falling. */
+interface RiverFall {
+  /** Where the water LANDS (local frame) — the plunge point. */
+  x: number;
+  z: number;
+  /** Water surface at the lip and at the base. */
+  topY: number;
+  baseY: number;
+  /** Vertical drop in meters. */
+  drop: number;
+  /** Channel half-width at the base — how wide the curtain is. */
+  halfWidth: number;
+  /** Downstream direction at the base (a fall keeps carrying the water). */
+  dirX: number;
+  dirZ: number;
+  /** Current speed at the base. */
+  speed: number;
+}
+interface DownhillTraceOptions {
+  /** Where the water starts (local frame, same as the sampler). */
+  x: number;
+  z: number;
+  /** Meters per step — also the gradient probe radius. */
+  step: number;
+  /** Stop after this many points (default 200). */
+  maxPoints?: number;
+  /** Half-extent of a square play area to stay inside (default: unbounded). */
+  bounds?: number;
+  /** Drop per step below which the water is judged to have pooled (default 1 %
+  * of the step — a genuinely flat basin, not a gentle reach). */
+  minDrop?: number;
+}
+/**
+* Trace where water would actually run from a point: repeated steepest descent
+* with momentum, so the line follows a valley floor instead of rattling between
+* its walls. Ends when the ground goes flat (a pool), the trace leaves the play
+* area, or `maxPoints` is reached.
+*
+* Feed the result straight into a {@link River3D} `path` — the terrain then
+* picks its own river, which is how a generated map gets water that belongs.
+*/
+declare function traceDownhillPath(bedAt: BedSampler, opts: DownhillTraceOptions): number[][];
+//#endregion
+//#region src/3d/nodes/river-3d.d.ts
+/**
+* A river: running water that finds its own shape.
+*
+* A scene declares a centerline `path`, a `width` (constant or a profile) and a
+* `depth`; the node samples the Terrain3D underneath and derives everything
+* else — a surface that descends with the ground and never climbs, a current
+* that speeds up where the channel pinches or tips, whitewater wherever those
+* two make it, and banks cut by the ground itself (each vertex carries its own
+* water column, and the shader stops drawing where that runs out).
+*
+* Unlike {@link Water3D} it costs no extra render passes — a river is a ribbon
+* with one draw call, so a map can carry a dozen of them.
+*
+* ```json
+* { "type": "River3D", "props": {
+*     "path": [[-80, -30], [-20, 5], [30, 10], [90, -10]],
+*     "widths": [3, 6, 11], "depth": 0.9, "flowSpeed": 1.8 } }
+* ```
+*/
+declare class River3D extends Node3D implements SunConsumer3D {
+  static override readonly typeName: string;
+  static override readonly props: PropSchema;
+  /** Centerline control points `[[x, z], …]` in the node's local frame. */
+  path: number[][];
+  /** Channel width in meters (constant unless `widths` overrides it). */
+  width: number;
+  /** Width profile lerped source→mouth, e.g. `[2, 5, 9]` for a stream growing
+  * into a river. Empty = the constant `width`. */
+  widths: number[];
+  /** Water column at the centerline, in meters. */
+  depth: number;
+  /** Reference current in m/s (the mean; reaches speed up and slow down). */
+  flowSpeed: number;
+  /** `{ shallow, deep, sky, horizon, bank }` — the body ramp plus what the
+  * surface mirrors (a grazing river mostly mirrors its BANK, not the sky). */
+  colors: JsonObject;
+  /** Beer's-law density: how fast the water hides its bed. */
+  absorption: number;
+  /** Upper bound on the body's opacity (1 = the deep reach goes solid). */
+  opacity: number;
+  /** Whitewater dial: 0 = a glassy canal, 1 = default, 2 = raging. */
+  foam: number;
+  /** Surface-detail dial: ripple relief and glitter. */
+  ripples: number;
+  /** Glint direction (the sky's sun overrides while this is at its default). */
+  sunDirection: number[];
+  sunColor: string;
+  sunIntensity: number;
+  /** Drape target path; empty = auto-find the first Terrain3D in the tree. */
+  terrain: string;
+  /** How hard the current sweeps bodies downstream (0 = visual only). */
+  flowForce: number;
+  /**
+  * Mist at the foot of every waterfall the course contains: the node finds
+  * the drops itself (see {@link detectFalls}) and hangs a Particles3D plume
+  * on each, sized by how far the water falls. 0 = off.
+  */
+  spray: number;
+  override renderOrder: number;
+  private time;
+  private rings;
+  private falls;
+  private sprayKey;
+  private courseKey;
+  private bedAt;
+  private world;
+  private readonly _bodies;
+  /** Loader hook: a malformed river fails at LOAD, not as an invisible ribbon. */
+  static validateJson(node: Node): void;
+  protected override _createObject3D(): Object3D;
+  override update(dt: number): void;
+  override _syncObject3D(): void;
+  /**
+  * Where a WORLD point sits in the channel — the query gameplay scripts run
+  * (steer a raft, drown a torch, decide a ford is too fast to cross). `null`
+  * until the river has been built.
+  */
+  sampleAt(x: number, z: number): (RiverHit & {
+    surfaceY: number;
+  }) | null;
+  /**
+  * The waterfalls on this course — where the water stops flowing and starts
+  * falling, with the drop height and the plunge point in WORLD coordinates.
+  * Hang your own effects (sound, a rainbow, a hidden cave) on these.
+  */
+  fallsAt(): (RiverFall & {
+    worldX: number;
+    worldY: number;
+    worldZ: number;
+  })[];
+  /** @internal The derived centerline stations (surface, grade, current). */
+  _rings(): readonly RiverRing[];
+  /**
+  * @internal Environment-sky sun hand-off (see {@link SunConsumer3D}): only
+  * while `sunDirection` sits at its schema default — an authored glint wins.
+  */
+  _applySunDirection(dir: readonly [number, number, number]): void;
+  override free(): void;
+  private widthProfile;
+  /** Resolve the drape terrain; an explicit path that misses is a hard error. */
+  private resolveTerrain;
+  /**
+  * Derive the course (stations + water column) when a shaping prop changed.
+  * Pure CPU work — no three objects — so gameplay can call it any time.
+  */
+  private ensureCourse;
+  private rebuildIfNeeded;
+  private buildMaterial;
+  private syncUniforms;
+  /**
+  * Hang a mist plume on every fall. Runtime children (`__spray*`), rebuilt
+  * only when the course or the dial changes — a plume is a Particles3D, so it
+  * carries its own budget, culling and editor visibility for free.
+  */
+  private syncSpray;
+  /**
+  * Drag every body floating in the channel toward the water's own velocity.
+  * Drag rather than thrust: a raft accelerates until it matches the current
+  * and then coasts, and a swimmer can still fight across a slow ford.
+  */
+  private sweepBodies;
+}
+//#endregion
 //#region src/3d/terrain/heightmap.d.ts
 /**
 * A smooth radial depression carved into the terrain — a lake/pond bowl. x/z
@@ -1555,6 +1779,17 @@ interface BasinSpec {
   /** > 0 carves a bowl; < 0 RAISES a smooth dome mound of that height. */
   depth: number;
 }
+/**
+* A river/road trench carved along a polyline: the line version of a basin.
+* `width` is the flat bed, `taper` the bank blend beyond it (default: the bed
+* width again, which is what makes a walkable V instead of a slot).
+*/
+interface ChannelSpec {
+  path: readonly (readonly number[])[];
+  width: number;
+  depth: number;
+  taper?: number;
+}
 interface HeightmapOptions {
   /** Terrain extent in meters along x. */
   width: number;
@@ -1584,6 +1819,8 @@ interface HeightmapOptions {
   edgeCornerSmoothness?: number;
   /** Smooth radial lake/pond bowls carved into the surface (interior basins). */
   basins?: BasinSpec[];
+  /** River/road trenches carved along polylines (see {@link ChannelSpec}). */
+  channels?: ChannelSpec[];
 }
 interface Heightmap {
   readonly width: number;
@@ -1709,6 +1946,10 @@ declare class Terrain3D extends Node3D {
   * collider + heightAt + dressing all see (place a Water3D in each).
   * NEGATIVE depth raises a smooth dome MOUND instead (a hill, an islet). */
   basins: BasinSpec[];
+  /** River/road trenches carved along polylines — `[{ path, width, depth,
+  * taper? }]`. The line counterpart of `basins`: what gives running water a
+  * bed to sit in, and the collider/heightAt/drape all see it. */
+  channels: ChannelSpec[];
   /**
   * WET SAND band: `{ y, band? }` darkens + glosses the splat in a noisy,
   * breathing band just above height `y` (a waterline) — the trace of the
@@ -2025,6 +2266,14 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   colors: JsonObject;
   /** CubeCamera reflections (fancy only; needs a live renderer). */
   reflection: boolean;
+  /**
+  * TRUE planar reflection: the scene re-rendered from the camera mirrored
+  * across this surface, sampled per fragment. A cube map can only carry
+  * distant content — the shoreline trees, the moored boat, the player at the
+  * water's edge only appear in the water with this on. Costs one extra scene
+  * render per frame, so it is off by default; a still lake earns it.
+  */
+  mirror: boolean;
   /** ms between reflection (and foam depth) re-renders. */
   reflectionInterval: number;
   /** Depth-texture shoreline foam — rides the always-on fancy scene pass. */
@@ -2069,6 +2318,13 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   swellDirectionDeg: number;
   /** Primary swell wavelength in meters (the two crossing trains derive). */
   swellWavelength: number;
+  /**
+  * GERSTNER pinch on the swell: 0 keeps the legacy height-only trains, 1 is
+  * maximum trochoid (crests narrow to a peak, troughs go broad). It also
+  * decides where whitecaps break — the surface's Jacobian collapses on a
+  * folding crest, and that is where foam belongs.
+  */
+  swellSteepness: number;
   /** Open-water whitecap foam on the tallest crests, 0–1 (fancy only). Works
   * best with `swell` — the caps ride the swell's crest lines. */
   whitecaps: number;
@@ -2118,6 +2374,9 @@ declare class Water3D extends Node3D implements RenderHook3D, SunConsumer3D {
   private lastReflectionAt;
   /** Per-frame scene pre-pass: depth (absorption/foam) + color grab (refraction). */
   private scenePassTarget;
+  private mirrorTarget;
+  private readonly mirrorCamera;
+  private readonly mirrorMatrix;
   protected override _createObject3D(): Object3D;
   override update(dt: number): void;
   override _syncObject3D(): void;
@@ -2451,4 +2710,4 @@ declare function createNavDebugNode(nav: TerrainNav, opts?: {
   name?: string;
 }): InstancedMesh3D;
 //#endregion
-export { Area3D, AssetStore3D, Billboard3D, type BillboardGroupMode, BoneAttachment3D, BoneLookAt3D, Camera3D, CharacterBody3D, CharacterController3D, type CreateGame3DOptions, DEFAULT_TERRAIN_TEXTURE_BASE, DirectionalLight3D, Environment3D, type Environment3DConfig, DENSITY_PRESETS as FLOWER_DENSITY_PRESETS, FLOWER_VARIETIES, type FlowerVariety, Flowers3D, type FogEnvironment, Foliage3D, type FoliageKind, type FoliageStyle, type Game3D, type HeightSampler, type Heightmap, type HeightmapOptions, InstancedMesh3D, Joint3D, type JointType3D, LoftMesh3D, type LoftSection, MeshInstance3D, type MeshKind, type MeshMaterialProps, type ModelEntry, ModelInstance3D, Node3D, OmniLight3D, Particles3D, Physics3D, type Physics3DOptions, PhysicsBody3D, QUARTER_PITCH, type RenderContext3D, type RenderHook3D, Renderer3D, type Renderer3DOptions, type RigView, RigidBody3D, type Ripple, type ShadowsEnvironment, type SkyEnvironment, StaticBody3D, type SunConsumer3D, type SyncOptions, type SyncResult, TERRAIN_THEMES, Terrain3D, type TerrainLayer, type TerrainNav, type TerrainNavOptions, type TerrainTheme, Trail3D, Tree3D, type TreeTier, type TreeType, VOXEL_PALETTE, type VoxelBlock, VoxelGrid3D, WATER_MAX_RIPPLES, Water3D, buildHeightmap, buildTerrainNav, cameraRelative, createGame3D, createNavDebugNode, enablePhysics3D, horizonColorFromSky, keyboardIntensity, movementState, parseEnvironment3D, registerNodes3D, resolveFlowerDensity, rigPose, setEnvironment3D, splatWeights, sunDirectionFromElevationAzimuth, sunDirectionFromSky, syncTree, terrainThemeLayers };
+export { Area3D, AssetStore3D, type BedSampler, Billboard3D, type BillboardGroupMode, BoneAttachment3D, BoneLookAt3D, Camera3D, CharacterBody3D, CharacterController3D, type CreateGame3DOptions, DEFAULT_TERRAIN_TEXTURE_BASE, DirectionalLight3D, type DownhillTraceOptions, Environment3D, type Environment3DConfig, DENSITY_PRESETS as FLOWER_DENSITY_PRESETS, FLOWER_VARIETIES, type FlowerVariety, Flowers3D, type FogEnvironment, Foliage3D, type FoliageKind, type FoliageStyle, type Game3D, type HeightSampler, type Heightmap, type HeightmapOptions, InstancedMesh3D, Joint3D, type JointType3D, LoftMesh3D, type LoftSection, MeshInstance3D, type MeshKind, type MeshMaterialProps, type ModelEntry, ModelInstance3D, Node3D, OmniLight3D, Particles3D, Physics3D, type Physics3DOptions, PhysicsBody3D, QUARTER_PITCH, type RenderContext3D, type RenderHook3D, Renderer3D, type Renderer3DOptions, type RigView, RigidBody3D, type Ripple, River3D, type RiverHit, type RiverRing, type ShadowsEnvironment, type SkyEnvironment, StaticBody3D, type SunConsumer3D, type SyncOptions, type SyncResult, TERRAIN_THEMES, Terrain3D, type TerrainLayer, type TerrainNav, type TerrainNavOptions, type TerrainTheme, Trail3D, Tree3D, type TreeTier, type TreeType, VOXEL_PALETTE, type VoxelBlock, VoxelGrid3D, WATER_MAX_RIPPLES, Water3D, buildHeightmap, buildTerrainNav, cameraRelative, createGame3D, createNavDebugNode, enablePhysics3D, horizonColorFromSky, keyboardIntensity, movementState, parseEnvironment3D, registerNodes3D, resolveFlowerDensity, rigPose, setEnvironment3D, splatWeights, sunDirectionFromElevationAzimuth, sunDirectionFromSky, syncTree, terrainThemeLayers, traceDownhillPath };

package/dist/3d.js

@@ -1,8 +1,8 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { a as Environment3D, c as sunDirectionFromElevationAzimuth, i as syncTree, l as sunDirectionFromSky, o as horizonColorFromSky, r as Renderer3D, s as parseEnvironment3D, t as createGame3D, u as AssetStore3D } from "./create-game-Ct6RC4LF.js";
-import { A as Joint3D, B as keyboardIntensity, C as BoneLookAt3D, D as DEFAULT_TERRAIN_TEXTURE_BASE, E as Terrain3D, F as StaticBody3D, H as rigPose, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, O as TERRAIN_THEMES, P as RigidBody3D, R as QUARTER_PITCH, S as Camera3D, T as Billboard3D, V as movementState, _ as DENSITY_PRESETS, a as VOXEL_PALETTE, b as FLOWER_VARIETIES, c as Trail3D, d as LoftMesh3D, f as DirectionalLight3D, g as Foliage3D, h as MeshInstance3D, i as WATER_MAX_RIPPLES, j as Area3D, k as terrainThemeLayers, l as Particles3D, m as InstancedMesh3D, n as Water3D, o as VoxelGrid3D, p as OmniLight3D, s as Tree3D, t as registerNodes3D, u as ModelInstance3D, v as Flowers3D, w as BoneAttachment3D, x as CharacterController3D, y as resolveFlowerDensity, z as cameraRelative } from "./register-Cv5GNiVo.js";
-import { n as splatWeights, t as buildHeightmap } from "./heightmap-DgX-Opav.js";
-import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-JPdedRAB.js";
+import { a as Environment3D, c as sunDirectionFromElevationAzimuth, i as syncTree, l as sunDirectionFromSky, o as horizonColorFromSky, r as Renderer3D, s as parseEnvironment3D, t as createGame3D, u as AssetStore3D } from "./create-game-xbxZRFwR.js";
+import { A as TERRAIN_THEMES, B as QUARTER_PITCH, C as CharacterController3D, D as Billboard3D, E as BoneAttachment3D, F as PhysicsBody3D, H as keyboardIntensity, I as RigidBody3D, L as StaticBody3D, M as Joint3D, N as Area3D, O as Terrain3D, P as CharacterBody3D, R as Node3D, S as FLOWER_VARIETIES, T as BoneLookAt3D, U as movementState, V as cameraRelative, W as rigPose, _ as MeshInstance3D, a as VoxelGrid3D, b as Flowers3D, c as River3D, d as Particles3D, f as ModelInstance3D, g as InstancedMesh3D, h as OmniLight3D, i as VOXEL_PALETTE, j as terrainThemeLayers, k as DEFAULT_TERRAIN_TEXTURE_BASE, l as traceDownhillPath, m as DirectionalLight3D, n as Water3D, o as Tree3D, p as LoftMesh3D, s as Trail3D, t as registerNodes3D, u as WATER_MAX_RIPPLES, v as Foliage3D, w as Camera3D, x as resolveFlowerDensity, y as DENSITY_PRESETS } from "./register-BC55Ez6I.js";
+import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
+import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-DHTZUrr0.js";
 //#region src/3d/environment-runtime.ts
 /**
 * Live environment editing — the renderer re-applies `scene.environment`
@@ -141,4 +141,4 @@ function createNavDebugNode(nav, opts) {
 	return node;
 }
 //#endregion
-export { Area3D, AssetStore3D, Billboard3D, BoneAttachment3D, BoneLookAt3D, Camera3D, CharacterBody3D, CharacterController3D, DEFAULT_TERRAIN_TEXTURE_BASE, DirectionalLight3D, Environment3D, DENSITY_PRESETS as FLOWER_DENSITY_PRESETS, FLOWER_VARIETIES, Flowers3D, Foliage3D, InstancedMesh3D, Joint3D, LoftMesh3D, MeshInstance3D, ModelInstance3D, Node3D, OmniLight3D, Particles3D, Physics3D, PhysicsBody3D, QUARTER_PITCH, Renderer3D, RigidBody3D, StaticBody3D, TERRAIN_THEMES, Terrain3D, Trail3D, Tree3D, VOXEL_PALETTE, VoxelGrid3D, WATER_MAX_RIPPLES, Water3D, buildHeightmap, buildTerrainNav, cameraRelative, createGame3D, createNavDebugNode, enablePhysics3D, horizonColorFromSky, keyboardIntensity, movementState, parseEnvironment3D, registerNodes3D, resolveFlowerDensity, rigPose, setEnvironment3D, splatWeights, sunDirectionFromElevationAzimuth, sunDirectionFromSky, syncTree, terrainThemeLayers };
+export { Area3D, AssetStore3D, Billboard3D, BoneAttachment3D, BoneLookAt3D, Camera3D, CharacterBody3D, CharacterController3D, DEFAULT_TERRAIN_TEXTURE_BASE, DirectionalLight3D, Environment3D, DENSITY_PRESETS as FLOWER_DENSITY_PRESETS, FLOWER_VARIETIES, Flowers3D, Foliage3D, InstancedMesh3D, Joint3D, LoftMesh3D, MeshInstance3D, ModelInstance3D, Node3D, OmniLight3D, Particles3D, Physics3D, PhysicsBody3D, QUARTER_PITCH, Renderer3D, RigidBody3D, River3D, StaticBody3D, TERRAIN_THEMES, Terrain3D, Trail3D, Tree3D, VOXEL_PALETTE, VoxelGrid3D, WATER_MAX_RIPPLES, Water3D, buildHeightmap, buildTerrainNav, cameraRelative, createGame3D, createNavDebugNode, enablePhysics3D, horizonColorFromSky, keyboardIntensity, movementState, parseEnvironment3D, registerNodes3D, resolveFlowerDensity, rigPose, setEnvironment3D, splatWeights, sunDirectionFromElevationAzimuth, sunDirectionFromSky, syncTree, terrainThemeLayers, traceDownhillPath };

package/dist/{create-game-Ct6RC4LF.js → create-game-xbxZRFwR.js}

@@ -5,8 +5,8 @@ import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
 import { n as registerGameplayBehaviors } from "./gameplay-sSqrUcnz.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { I as Node3D, N as PhysicsBody3D, S as Camera3D, f as DirectionalLight3D, r as createCausticsQuad, t as registerNodes3D, u as ModelInstance3D } from "./register-Cv5GNiVo.js";
-import { n as enablePhysics3D } from "./physics-3d-JPdedRAB.js";
+import { F as PhysicsBody3D, R as Node3D, f as ModelInstance3D, m as DirectionalLight3D, r as createCausticsQuad, t as registerNodes3D, w as Camera3D } from "./register-BC55Ez6I.js";
+import { n as enablePhysics3D } from "./physics-3d-DHTZUrr0.js";
 import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";

package/dist/env.js

@@ -1,7 +1,7 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
-import { t as buildHeightmap } from "./heightmap-DgX-Opav.js";
+import { t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
 //#region src/env/round.ts
 /** 2-decimal rounding — keeps generated JSON readable without hurting determinism. */
 function round2(value) {

package/dist/{heightmap-DgX-Opav.js → heightmap-CRK0M4jT.js}

@@ -34,6 +34,20 @@ function buildHeightmap(opts) {
 		radius: b.radius,
 		depth: b.depth
 	}));
+	const channels = (opts.channels ?? []).map((c) => ({
+		half: Math.max(c.width, 0) / 2,
+		taper: Math.max(c.taper ?? c.width, .001),
+		depth: c.depth,
+		segs: c.path.map((p) => ({
+			x: (p[0] ?? 0) + width / 2,
+			z: (p[1] ?? 0) + depth / 2
+		})).flatMap((p, i, all) => i === 0 ? [] : [{
+			ax: all[i - 1].x,
+			az: all[i - 1].z,
+			bx: p.x,
+			bz: p.z
+		}])
+	})).filter((c) => c.segs.length > 0 && c.depth !== 0);
 	const simplex = createNoise2D(seed);
 	/** Ported: noise remapped from [-1,1] to [0,1]. */
 	const noise01 = (x, y) => (simplex(x, y) + 1) * .5;
@@ -76,6 +90,27 @@ function buildHeightmap(opts) {
 			}
 			final += lift - carve;
 		}
+		if (channels.length > 0) {
+			let cut = 0;
+			for (const c of channels) {
+				let best = Number.POSITIVE_INFINITY;
+				for (const s of c.segs) {
+					const dx = s.bx - s.ax;
+					const dz = s.bz - s.az;
+					const len2 = dx * dx + dz * dz;
+					const t = len2 > 1e-9 ? Math.min(1, Math.max(0, ((x - s.ax) * dx + (z - s.az) * dz) / len2)) : 0;
+					const px = s.ax + dx * t;
+					const pz = s.az + dz * t;
+					const d = Math.hypot(x - px, z - pz);
+					if (d < best) best = d;
+					if (best <= c.half) break;
+				}
+				if (best >= c.half + c.taper) continue;
+				const t = Math.min(1, Math.max(0, (best - c.half) / c.taper));
+				cut = Math.max(cut, c.depth * (1 - t * t * (3 - 2 * t)));
+			}
+			final -= cut;
+		}
 		return final;
 	};
 	/** Quarter-circle edge wrap: drop = R − √(R²−s²), p-norm corner rounding. */

package/dist/index.js

@@ -295,6 +295,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.19.0";
+const VERSION = "0.21.0";
 //#endregion
 export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, UiBanner, UiBar, UiButton, UiDialogue, UiText, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, auditScene, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, findPath, getBehavior, getNodeSchema, getNodeSignals, getNodeType, gridFromRows, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, replay, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, startRecording, synthSfx };

package/dist/{physics-3d-JPdedRAB.js → physics-3d-DHTZUrr0.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { A as Joint3D, E as Terrain3D, I as Node3D, L as validateCollider3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./register-Cv5GNiVo.js";
+import { F as PhysicsBody3D, I as RigidBody3D, M as Joint3D, N as Area3D, O as Terrain3D, P as CharacterBody3D, R as Node3D, z as validateCollider3D } from "./register-BC55Ez6I.js";
 import { Euler, Quaternion } from "three";
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-Ct6RC4LF.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-Ct86zczq.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-xbxZRFwR.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-Ct86zczq.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;