@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/vegetation/core/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/tree.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAU/B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmNnB,CAAC;AAIF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAcrC;AAgBD,sGAAsG;AACtG,wBAAgB,aAAa,CAAC,CAAC,KAAA,OAQ9B;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAA2F,CAAC"}

package/dist/components/vegetation/core/tree.js

@@ -0,0 +1,408 @@
+// Emitted from Claude outputs/vegetation-lab/tree.mjs by gen_family.mjs — edit the lab module and re-emit.
+// vegetation/core/tree — Tree (type 'vegetation', config.type 'tree'). Shared core: ../vegetationCore.
+// Construction:
+//   skeleton  a parametric branching model (Weber–Penn): trunk → 1–3 levels of branches, each
+//             level with a child count, length/radius ratios, down angle, phyllotactic rotation,
+//             curvature, gravity (droop) and phototropism; the crown silhouette is a shape function
+//             of the attachment height. A species is one parameter set; the knobs scale it.
+//   bark      one merged generalized-cylinder mesh (fewer sides on thinner branches), procedural
+//             ridged bark as a bump, moss low on the trunk.
+//   leaves    instanced cards along the last levels, shaped per leaf type (SDF), coloured by the
+//             per-leaf hash, canopy depth and season, translucent against the sun.
+//   wind      hierarchical: the trunk leans with travelling gusts (∝ height²), branches sway at their
+//             own phase and flexibility, leaves flutter; one field shared by bark, leaves and fruit.
+//   fruit     instanced spheroids shaped and skinned per kind, hanging from the outer leaves,
+//             ripening (two colours) across the crown.
+//   fall      analytic falling leaves, released by the season, a knob, or the cursor's rustle.
+// Size: the unit box — the transform scale is the tree's width and height.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, LEAF_TYPES, QUALITY_V, generatePlant, branchGeometry, leafGeometry, fillLeaves, unitBounds, barkMaterial, leafMaterial, fruitMaterial, applyFruitConfig, fruitGeometry, fillFruit, fallingMaterial, plantMesh, flowerHeads, plantLod, lodOrder, } from '../vegetationCore.js';
+// ----------------------------------------------------------------------------- species
+// Lengths relative to the trunk length; the whole plant is fitted to the unit box afterwards.
+export const SPECIES = {
+    oak: {
+        leaf: 'lobed', bark: '#5a4632', autumn: ['#d99a1e', '#9c3a16'],
+        levels: 3, droop: 0.05, twist: 0.7, photo: 0.35, branchiness: 1,
+        // a short trunk forking into three or four heavy limbs, each with two more levels of branching
+        trunk: { length: 0.34, radius: 0.055, taper: 0.3, curve: 6, segments: 6, flex: 0.05, splits: 3, splitAngle: 32, splitLength: 1.1, splitRadius: 0.72 },
+        level: [
+            { count: 4, length: 0.9, radius: 0.6, downAngle: 55, downVar: 30, curve: 30, curveVar: 1.2, segments: 5, start: 0.55, splits: 2, splitAngle: 30, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 8, length: 0.6, radius: 0.6, downAngle: 50, downVar: 40, curve: 25, segments: 4, start: 0.2 },
+            { count: 9, length: 0.5, radius: 0.5, downAngle: 45, downVar: 50, curve: 20, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.55 + 0.6 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 150, size: 0.024, sizeVar: 0.5, spread: 0.8, lift: 0.3, fromLevel: 1, tuft: 2, start: 0.15 },
+    },
+    maple: {
+        leaf: 'maple', bark: '#6b5a4a', autumn: ['#e8821c', '#c0281c'],
+        levels: 3, droop: 0.05, twist: 0.4, photo: 0.4, branchiness: 1,
+        trunk: { length: 0.3, radius: 0.045, taper: 0.3, curve: 3, segments: 5, flex: 0.05, splits: 3, splitAngle: 26, splitLength: 1.2, splitRadius: 0.7 },
+        level: [
+            { count: 3, length: 0.8, radius: 0.6, downAngle: 40, downVar: 25, curve: 20, curveVar: 1, segments: 5, start: 0.5, splits: 2, splitAngle: 28, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 5, length: 0.6, radius: 0.6, downAngle: 40, downVar: 35, curve: 15, segments: 4, start: 0.2 },
+            { count: 5, length: 0.5, radius: 0.5, downAngle: 40, downVar: 40, curve: 15, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.5 + 0.7 * Math.sin(Math.PI * (0.05 + 0.9 * t)),
+        leaves: { perLength: 80, size: 0.022, sizeVar: 0.4, spread: 0.8, lift: 0.3, fromLevel: 1, tuft: 2, start: 0.15 },
+    },
+    pine: {
+        leaf: 'needles', bark: '#4e3a2c', autumn: ['#7a6a2a', '#5a4a1a'],
+        levels: 2, droop: 0.35, twist: 0.15, photo: 0.1, branchiness: 1, whorls: 5,
+        trunk: { length: 1, radius: 0.04, taper: 0.9, curve: 1, segments: 12, flex: 0.03 },
+        level: [
+            { count: 40, length: 0.42, radius: 0.35, downAngle: 82, downVar: 10, curve: -12, curveVar: 0.5, segments: 4, start: 0.3 },
+            { count: 6, length: 0.45, radius: 0.5, downAngle: 50, downVar: 30, curve: 5, segments: 3, start: 0.25 },
+        ],
+        shape: (t) => Math.max(0.08, 1.05 - 0.95 * t),
+        leaves: { perLength: 90, size: 0.03, sizeVar: 0.3, spread: 1.1, lift: 0.1, fromLevel: 0, tuft: 2, start: 0.1, faceUp: 0.4 },
+    },
+    birch: {
+        leaf: 'broadleaf', bark: '#d8d4c8', autumn: ['#f0c21a', '#d99a1e'],
+        levels: 3, droop: 0.5, twist: 0.3, photo: 0.3, branchiness: 1,
+        trunk: { length: 0.5, radius: 0.028, taper: 0.7, curve: 4, segments: 8, flex: 0.08, lean: 0.1 },
+        level: [
+            { count: 9, length: 0.9, radius: 0.5, downAngle: 38, downVar: 20, curve: 15, curveVar: 1, segments: 4, start: 0.35 },
+            { count: 5, length: 0.6, radius: 0.55, downAngle: 45, downVar: 30, curve: 25, segments: 4, start: 0.2 },
+            { count: 5, length: 0.55, radius: 0.5, downAngle: 60, downVar: 40, curve: 30, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.5 + 0.5 * Math.sin(Math.PI * (0.2 + 0.7 * t)),
+        leaves: { perLength: 60, size: 0.022, sizeVar: 0.4, spread: 0.9, lift: 0.1, fromLevel: 1, tuft: 2, start: 0.1 },
+    },
+    willow: {
+        leaf: 'lanceolate', bark: '#6a5a44', autumn: ['#d9c21e', '#b89a1e'],
+        levels: 3, droop: 1.3, twist: 0.3, photo: 0.6, branchiness: 1,
+        trunk: { length: 0.3, radius: 0.05, taper: 0.4, curve: 8, segments: 5, flex: 0.05 },
+        level: [
+            { count: 7, length: 1.3, radius: 0.6, downAngle: 35, downVar: 25, curve: 10, curveVar: 1, segments: 5, start: 0.5 },
+            { count: 6, length: 0.9, radius: 0.45, downAngle: 40, downVar: 30, curve: 10, segments: 6, start: 0.3 },
+            { count: 4, length: 0.8, radius: 0.4, downAngle: 30, downVar: 30, curve: 5, segments: 6, start: 0.2 },
+        ],
+        shape: (t) => 0.6 + 0.5 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 110, size: 0.03, sizeVar: 0.4, spread: 0.9, lift: -0.4, fromLevel: 2, tuft: 2, start: 0.05 },
+    },
+    palm: {
+        leaf: 'lanceolate', bark: '#8a7a5a', autumn: ['#b8a040', '#8a6a2a'],
+        levels: 1, droop: 1.6, twist: 0.05, photo: 0, branchiness: 1,
+        trunk: { length: 1, radius: 0.035, taper: 0.3, curve: 14, segments: 10, flex: 0.1, lean: 0.25 },
+        level: [
+            // the fronds: arching rachises from the crown, leaflets in two ranks along them
+            { count: 18, length: 0.55, radius: 0.3, downAngle: 25, downVar: 50, curve: 30, curveVar: 0.4, segments: 8, start: 0.97, azVar: 1.5 },
+        ],
+        shape: () => 1,
+        leaves: { perLength: 150, size: 0.055, sizeVar: 0.2, spread: 1.6, lift: -0.15, fromLevel: 0, tuft: 2, start: 0.12, faceUp: 0.6 },
+    },
+    cypress: {
+        leaf: 'needles', bark: '#5a4a3a', autumn: ['#7a6a2a', '#5a4a1a'],
+        levels: 2, droop: -0.2, twist: 0.2, photo: 0.5, branchiness: 1,
+        trunk: { length: 1, radius: 0.03, taper: 0.9, curve: 1, segments: 12, flex: 0.04 },
+        level: [
+            { count: 50, length: 0.18, radius: 0.4, downAngle: 30, downVar: 15, curve: -10, segments: 3, start: 0.05 },
+            { count: 5, length: 0.5, radius: 0.5, downAngle: 35, downVar: 30, curve: 5, segments: 3, start: 0.2 },
+        ],
+        shape: (t) => 0.4 + 0.6 * Math.sin(Math.PI * (0.05 + 0.9 * t)),
+        leaves: { perLength: 110, size: 0.024, sizeVar: 0.3, spread: 1, lift: 0.4, fromLevel: 0, tuft: 2, start: 0.1, faceUp: 0.6 },
+    },
+    olive: {
+        leaf: 'lanceolate', bark: '#8a8070', autumn: ['#9a9a6a', '#7a7a5a'],
+        levels: 3, droop: 0.25, twist: 1.2, photo: 0.2, branchiness: 1,
+        trunk: { length: 0.3, radius: 0.07, taper: 0.35, curve: 18, segments: 7, flex: 0.03, splits: 3, splitAngle: 38, splitLength: 0.9, splitRadius: 0.7 },
+        level: [
+            { count: 4, length: 0.8, radius: 0.6, downAngle: 50, downVar: 40, curve: 35, curveVar: 1.5, segments: 5, start: 0.5, splits: 2, splitAngle: 35, splitLength: 0.75, splitRadius: 0.75 },
+            { count: 7, length: 0.6, radius: 0.6, downAngle: 55, downVar: 40, curve: 30, segments: 4, start: 0.2 },
+            { count: 8, length: 0.5, radius: 0.5, downAngle: 50, downVar: 50, curve: 25, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.6 + 0.5 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 140, size: 0.02, sizeVar: 0.4, spread: 0.9, lift: 0.1, fromLevel: 1, tuft: 2, start: 0.1 },
+        leafColor: '#7f8f5a', shade: '#3a4a2a',
+    },
+    cherryBlossom: {
+        leaf: 'broadleaf', bark: '#4a3a34', autumn: ['#e8a03a', '#c0502a'],
+        levels: 3, droop: 0.1, twist: 0.5, photo: 0.3, branchiness: 1,
+        trunk: { length: 0.3, radius: 0.045, taper: 0.3, curve: 8, segments: 6, flex: 0.05, splits: 3, splitAngle: 35, splitLength: 1.0, splitRadius: 0.7 },
+        level: [
+            { count: 4, length: 0.85, radius: 0.6, downAngle: 50, downVar: 30, curve: 25, curveVar: 1, segments: 5, start: 0.5, splits: 2, splitAngle: 32, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 7, length: 0.6, radius: 0.6, downAngle: 50, downVar: 40, curve: 20, segments: 4, start: 0.2 },
+            { count: 8, length: 0.5, radius: 0.5, downAngle: 45, downVar: 50, curve: 20, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.6 + 0.6 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 60, size: 0.02, sizeVar: 0.4, spread: 0.8, lift: 0.2, fromLevel: 1, tuft: 2, start: 0.1 },
+        blossom: { petals: 5, size: 0.012, color: '#f6c6d6', head: 3, cup: 0.35 }, flowersAlways: 0.9, leafColor: '#6a9a3a',
+    },
+    magnolia: {
+        leaf: 'broadleaf', bark: '#7a7a72', autumn: ['#b89a3a', '#8a6a2a'],
+        levels: 3, droop: 0.1, twist: 0.5, photo: 0.4, branchiness: 1,
+        trunk: { length: 0.25, radius: 0.045, taper: 0.3, curve: 6, segments: 5, flex: 0.05, splits: 4, splitAngle: 40, splitLength: 1.1, splitRadius: 0.7 },
+        level: [
+            { count: 3, length: 0.8, radius: 0.6, downAngle: 50, downVar: 30, curve: 20, curveVar: 1, segments: 5, start: 0.4, splits: 2, splitAngle: 35, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 6, length: 0.6, radius: 0.6, downAngle: 50, downVar: 40, curve: 20, segments: 4, start: 0.2 },
+            { count: 6, length: 0.5, radius: 0.5, downAngle: 45, downVar: 50, curve: 20, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.7 + 0.5 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 40, size: 0.028, sizeVar: 0.4, spread: 0.8, lift: 0.2, fromLevel: 1, tuft: 2, start: 0.1 },
+        blossom: { petals: 9, size: 0.03, color: '#f2d6e6', head: 1, cup: 0.6 }, flowersAlways: 0.7, leafColor: '#4f7a3a',
+    },
+    jacaranda: {
+        leaf: 'frond', bark: '#6a6056', autumn: ['#c8a84a', '#9a7a3a'],
+        levels: 3, droop: 0.2, twist: 0.4, photo: 0.4, branchiness: 1,
+        trunk: { length: 0.35, radius: 0.045, taper: 0.3, curve: 6, segments: 6, flex: 0.05, splits: 3, splitAngle: 35, splitLength: 1.0, splitRadius: 0.7 },
+        level: [
+            { count: 4, length: 0.9, radius: 0.6, downAngle: 50, downVar: 30, curve: 20, curveVar: 1, segments: 5, start: 0.5, splits: 2, splitAngle: 32, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 7, length: 0.6, radius: 0.6, downAngle: 50, downVar: 40, curve: 20, segments: 4, start: 0.2 },
+            { count: 8, length: 0.5, radius: 0.5, downAngle: 45, downVar: 50, curve: 20, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.7 + 0.6 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 50, size: 0.035, sizeVar: 0.3, spread: 0.9, lift: 0.0, fromLevel: 1, tuft: 2, start: 0.1 },
+        blossom: { petals: 5, size: 0.01, color: '#8a74d8', head: 6, cup: 0.6 }, flowersAlways: 0.9, leafColor: '#5f9a3a',
+    },
+    acacia: {
+        leaf: 'frond', bark: '#5a4a3a', autumn: ['#b8a84a', '#8a7a3a'],
+        levels: 3, droop: -0.1, twist: 0.6, photo: 0.9, branchiness: 1,
+        trunk: { length: 0.45, radius: 0.04, taper: 0.3, curve: 10, segments: 6, flex: 0.05, splits: 3, splitAngle: 55, splitLength: 0.9, splitRadius: 0.7 },
+        level: [
+            { count: 3, length: 0.8, radius: 0.6, downAngle: 70, downVar: 20, curve: -25, curveVar: 0.6, segments: 5, start: 0.5, splits: 2, splitAngle: 45, splitLength: 0.7, splitRadius: 0.75 },
+            { count: 7, length: 0.5, radius: 0.6, downAngle: 70, downVar: 30, curve: -15, segments: 4, start: 0.3 },
+            { count: 8, length: 0.45, radius: 0.5, downAngle: 60, downVar: 40, curve: -10, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.4 + 0.9 * t,
+        leaves: { perLength: 70, size: 0.028, sizeVar: 0.3, spread: 1.0, lift: 0.5, fromLevel: 1, tuft: 2, start: 0.2, faceUp: 1 },
+        blossom: { petals: 10, size: 0.007, color: '#f2d040', head: 5, cup: 0.2, type: 'round' }, leafColor: '#6f9a3a',
+    },
+    baobab: {
+        leaf: 'broadleaf', bark: '#9a8a78', autumn: ['#b8a84a', '#8a7a3a'],
+        levels: 2, droop: -0.1, twist: 0.5, photo: 0.6, branchiness: 1,
+        trunk: { length: 0.7, radius: 0.16, taper: 0.25, curve: 3, segments: 6, flex: 0.01, splits: 5, splitAngle: 50, splitLength: 0.45, splitRadius: 0.45 },
+        level: [
+            { count: 3, length: 0.5, radius: 0.55, downAngle: 55, downVar: 30, curve: 10, curveVar: 1, segments: 4, start: 0.5, splits: 2, splitAngle: 45, splitLength: 0.7, splitRadius: 0.7 },
+            { count: 5, length: 0.5, radius: 0.5, downAngle: 50, downVar: 40, curve: 10, segments: 3, start: 0.2 },
+        ],
+        shape: () => 1,
+        leaves: { perLength: 40, size: 0.02, sizeVar: 0.4, spread: 0.9, lift: 0.2, fromLevel: 1, tuft: 2, start: 0.2 },
+        leafColor: '#6a9a3a',
+    },
+    spruce: {
+        leaf: 'needles', bark: '#5a4535', autumn: ['#7a6a2a', '#5a4a1a'],
+        levels: 2, droop: 0.55, twist: 0.1, photo: 0.05, branchiness: 1, whorls: 6,
+        trunk: { length: 1, radius: 0.04, taper: 0.92, curve: 1, segments: 14, flex: 0.03 },
+        level: [
+            { count: 66, length: 0.38, radius: 0.35, downAngle: 88, downVar: 8, curve: -8, curveVar: 0.4, segments: 4, start: 0.12 },
+            { count: 8, length: 0.4, radius: 0.5, downAngle: 60, downVar: 25, curve: 5, segments: 3, start: 0.2 },
+        ],
+        shape: (t) => Math.max(0.05, 1.0 - 0.95 * t),
+        leaves: { perLength: 120, size: 0.022, sizeVar: 0.3, spread: 1.1, lift: -0.1, fromLevel: 0, tuft: 2, start: 0.05, faceUp: 0.3 },
+        leafColor: '#2a5a30', shade: '#102414',
+    },
+    poplar: {
+        leaf: 'broadleaf', bark: '#7a7a6a', autumn: ['#f0c21a', '#d99a1e'],
+        levels: 3, droop: -0.4, twist: 0.2, photo: 1.0, branchiness: 1,
+        trunk: { length: 1, radius: 0.035, taper: 0.8, curve: 1, segments: 10, flex: 0.06 },
+        level: [
+            { count: 40, length: 0.25, radius: 0.4, downAngle: 25, downVar: 15, curve: -10, segments: 4, start: 0.1 },
+            { count: 4, length: 0.6, radius: 0.5, downAngle: 30, downVar: 30, curve: -10, segments: 3, start: 0.2 },
+            { count: 4, length: 0.5, radius: 0.5, downAngle: 30, downVar: 40, curve: 0, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.5 + 0.6 * Math.sin(Math.PI * (0.05 + 0.9 * t)),
+        leaves: { perLength: 90, size: 0.02, sizeVar: 0.4, spread: 0.9, lift: 0.1, fromLevel: 1, tuft: 2, start: 0.1 },
+        leafColor: '#5f9a3a',
+    },
+    eucalyptus: {
+        leaf: 'lanceolate', bark: '#c8b8a8', autumn: ['#a8a86a', '#7a7a5a'],
+        levels: 3, droop: 0.6, twist: 0.6, photo: 0.5, branchiness: 1,
+        trunk: { length: 0.55, radius: 0.04, taper: 0.5, curve: 8, segments: 8, flex: 0.06, splits: 2, splitAngle: 25, splitLength: 0.9, splitRadius: 0.7 },
+        level: [
+            { count: 4, length: 0.7, radius: 0.55, downAngle: 45, downVar: 30, curve: 20, curveVar: 1, segments: 5, start: 0.6, splits: 2, splitAngle: 30, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 6, length: 0.6, radius: 0.55, downAngle: 50, downVar: 40, curve: 20, segments: 4, start: 0.2 },
+            { count: 6, length: 0.55, radius: 0.5, downAngle: 55, downVar: 50, curve: 20, segments: 4, start: 0.1 },
+        ],
+        shape: (t) => 0.5 + 0.5 * Math.sin(Math.PI * (0.15 + 0.75 * t)),
+        leaves: { perLength: 90, size: 0.03, sizeVar: 0.4, spread: 0.6, lift: -0.5, fromLevel: 2, tuft: 2, start: 0.05 },
+        leafColor: '#7a9a7a', shade: '#2f4a3a',
+    },
+    bare: {
+        leaf: 'broadleaf', bark: '#5a4a3a', autumn: ['#8a6a2a', '#5a3a1a'],
+        levels: 3, droop: 0.1, twist: 1.0, photo: 0.3, branchiness: 1.2,
+        trunk: { length: 0.3, radius: 0.05, taper: 0.3, curve: 10, segments: 6, flex: 0.03, splits: 3, splitAngle: 35, splitLength: 1.0, splitRadius: 0.7 },
+        level: [
+            { count: 4, length: 0.9, radius: 0.6, downAngle: 55, downVar: 35, curve: 35, curveVar: 1.5, segments: 5, start: 0.5, splits: 2, splitAngle: 35, splitLength: 0.8, splitRadius: 0.75 },
+            { count: 8, length: 0.6, radius: 0.6, downAngle: 50, downVar: 45, curve: 30, segments: 4, start: 0.2 },
+            { count: 9, length: 0.5, radius: 0.5, downAngle: 45, downVar: 55, curve: 25, segments: 3, start: 0.1 },
+        ],
+        shape: (t) => 0.6 + 0.6 * Math.sin(Math.PI * (0.1 + 0.8 * t)),
+        leaves: { perLength: 2, size: 0.02, sizeVar: 0.4, spread: 0.8, lift: 0.2, fromLevel: 2, tuft: 1, start: 0.5 },
+        foliageAlways: 0,
+    },
+};
+const LEAF_BASE = 34000, FALL_BASE = 400, FRUIT_BASE = 320;
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, mats) {
+    if (c.species !== undefined)
+        c = Object.assign({}, c, speciesColors(c));
+    applyCommonConfig(u, c);
+    if (c.leafType !== undefined || c.species !== undefined) {
+        const sp = SPECIES[c.species] || SPECIES.oak;
+        const lt = !c.leafType || c.leafType === 'auto' ? sp.leaf : c.leafType;
+        u.uLeafType.value = Math.max(0, LEAF_TYPES.indexOf(lt));
+    }
+    if (!mats)
+        return;
+    if (c.barkColor !== undefined)
+        setColor(mats.bark.userData.uniforms.uBarkColor, c.barkColor);
+    if (c.leafFall !== undefined)
+        mats.fall.userData.uniforms.uLeafFall.value = c.leafFall;
+    if (c.flowers !== undefined && mats.flowerU)
+        mats.flowerU.uFoliage.value = c.flowers;
+    if (c.flowerColor !== undefined && c.flowerColor !== '#ffffff' && mats.flowerU)
+        setColor(mats.flowerU.uColor, c.flowerColor);
+    applyFruitConfig(mats.fruit, c);
+}
+/** Fits the generated plant to the unit box: width 1 (x/z), height 1 (y). */
+function fitUnit(plant) {
+    let maxY = 1e-6, maxR = 1e-6;
+    for (const b of plant.branches)
+        for (const p of b.pts) {
+            if (p.y > maxY)
+                maxY = p.y;
+            const r = Math.hypot(p.x, p.z);
+            if (r > maxR)
+                maxR = r;
+        }
+    for (const l of plant.leaves) {
+        if (l.pos.y + l.size > maxY)
+            maxY = l.pos.y + l.size;
+        const r = Math.hypot(l.pos.x, l.pos.z) + l.size * 0.7;
+        if (r > maxR)
+            maxR = r;
+    }
+    const sy = 1 / maxY, sxz = 0.5 / maxR, sr = Math.sqrt(sy * sxz);
+    const S = new THREE.Vector3(sxz, sy, sxz);
+    for (const b of plant.branches) {
+        for (const p of b.pts) {
+            p.multiply(S);
+            if (p.y < 0.01)
+                p.y = 0.01;
+        }
+        for (let i = 0; i < b.radii.length; i++)
+            b.radii[i] *= sr;
+    }
+    for (const l of plant.leaves) {
+        l.pos.multiply(S);
+        l.along.multiply(S).normalize();
+        l.normal.multiply(S).normalize();
+        l.size *= sr;
+        l.hf = Math.min(1, Math.max(0, l.pos.y));
+    }
+    for (const b of plant.branches)
+        b.hf0 = Math.min(1, Math.max(0, b.pts[0].y));
+    return plant;
+}
+const SPECIES_LEAF = new Set(Object.values(SPECIES).map((s) => (s['leafColor'] || '#4f8a3a').toLowerCase()).concat(['#4f8a3a']));
+/** Leaf / bark colours the user has not customised (a species default) follow the current species. */
+export function speciesColors(c) {
+    const sp = SPECIES[c.species] || SPECIES.oak;
+    const barks = new Set(Object.values(SPECIES).map((s) => s.bark.toLowerCase()).concat(['#6e5844']));
+    const out = Object.create(null); // only the keys set below override the config
+    if (!c.color || SPECIES_LEAF.has(c.color.toLowerCase()))
+        out.color = sp.leafColor || '#4f8a3a';
+    if (!c.shadeColor || c.shadeColor.toLowerCase() === '#1f3d1a' || Object.values(SPECIES).some((s) => s['shade'] && s['shade'].toLowerCase() === c.shadeColor.toLowerCase()))
+        out.shadeColor = sp.shade || '#1f3d1a';
+    if (!c.barkColor || barks.has(c.barkColor.toLowerCase()))
+        out.barkColor = sp.bark;
+    return out;
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const sp = SPECIES[c.species] || SPECIES.oak;
+    c = Object.assign({}, c, speciesColors(c));
+    const rnd = mulberry32((c.seed ?? 7) * 2654435761 + 17);
+    // the knobs scale the species: trunk share, branch counts, gravity, wander
+    const P = Object.assign({}, sp, {
+        trunk: Object.assign({}, sp.trunk, { length: sp.trunk.length * (c.trunkRatio ?? 1) }),
+        branchiness: (sp.branchiness || 1) * (c.branchiness ?? 1),
+        droop: (sp.droop || 0) + (c.droop ?? 0),
+        twist: (sp.twist || 0) + (c.twist ?? 0.5) - 0.5,
+        leaves: Object.assign({}, sp.leaves, { density: 1 }),
+    });
+    const plant = fitUnit(generatePlant(P, rnd));
+    // leaf budget: density × quality; keep coverage by growing the cards when thinning
+    let leaves = plant.leaves;
+    const target = Math.round(LEAF_BASE * (c.density ?? 1) * q);
+    if (leaves.length > target) {
+        const grow = Math.min(1.8, Math.sqrt(leaves.length / Math.max(target, 1)));
+        const picked = [];
+        for (let i = 0; i < target; i++)
+            picked.push(leaves[Math.floor(rnd() * leaves.length)]);
+        picked.forEach((l) => { l.size *= grow; });
+        leaves = picked;
+    }
+    leaves = lodOrder(leaves, c.seed ?? 7); // drawing the first K at distance is an even thinning
+    const mats = { bark: null, leaf: null, fruit: null, fall: null, flowerU: null };
+    const barkPair = barkMaterial(u, { barkColor: c.barkColor || sp.bark, lod: true });
+    const leafPair = leafMaterial(u, { autumnA: sp.autumn[0], autumnB: sp.autumn[1], translucency: sp.leaf === 'needles' ? 0.25 : 0.55, lod: true });
+    const fruitPair = fruitMaterial(u);
+    const fallPair = fallingMaterial(u);
+    fallPair.material.userData.uniforms.uAutumnA.value.set(sp.autumn[0]);
+    fallPair.material.userData.uniforms.uAutumnB.value.set(sp.autumn[1]);
+    mats.bark = barkPair.material;
+    mats.leaf = leafPair.material;
+    mats.fruit = fruitPair.material;
+    mats.fall = fallPair.material;
+    // root flare and buttresses at the foot of the trunk
+    const flare = (br, i, a) => { if (br.level !== -1)
+        return 1; const y = br.pts[i].y; const e = Math.exp(-y / 0.035); return 1 + 0.9 * e + 0.5 * e * Math.pow(Math.max(0, Math.cos(a * 3 + 0.7)), 2) + 0.15 * Math.exp(-y / 0.12); };
+    const barkGeo = branchGeometry(plant.branches, { sides: [16, 9, 6, 4], flare });
+    const leafGeo = leafGeometry(Math.max(1, leaves.length));
+    fillLeaves(leafGeo, leaves);
+    unitBounds(leafGeo);
+    const fallGeo = leafGeometry(Math.round(FALL_BASE * q));
+    fillLeaves(fallGeo, leaves.length ? Array.from({ length: fallGeo.instanceCount }, () => leaves[Math.floor(rnd() * leaves.length)]).map((l, i) => Object.assign({}, l, { order: (i + 0.5) / fallGeo.instanceCount })) : []);
+    unitBounds(fallGeo);
+    const fruitGeo = fruitGeometry(Math.round(FRUIT_BASE * q), 12);
+    if (leaves.length)
+        fillFruit(fruitGeo, leaves, rnd, 0.014);
+    unitBounds(fruitGeo);
+    // blossom: fans of petals at the twig tips, for the flowering species (or any, with a flowers knob > 0)
+    const tips = plant.branches.filter((b) => b.level >= P.levels - 1);
+    const bl = sp.blossom || { petals: 5, size: 0.012, color: '#f6e6f0', head: 2, cup: 0.35 };
+    const heads = flowerHeads(u, tips, rnd, Object.assign({}, bl, { color: c.flowerColor && c.flowerColor !== '#ffffff' ? c.flowerColor : bl.color }), Math.round(1600 * q / Math.max(1, bl.head)), { lod: true });
+    mats.flowerU = heads.U;
+    const blossom = plantMesh(heads.geo, heads.pair, 'blossom');
+    const bark = plantMesh(barkGeo, barkPair, 'bark');
+    const foliage = plantMesh(leafGeo, leafPair, 'leaves');
+    const falling = plantMesh(fallGeo, fallPair, 'falling');
+    const fruit = plantMesh(fruitGeo, fruitPair, 'fruit');
+    const object = new THREE.Group();
+    object.name = 'tree';
+    object.add(bark, foliage, blossom, fruit, falling);
+    const lod = plantLod(u, object, {
+        leaves: [foliage, blossom], bark: [bark], other: [fruit, falling], bake: [bark, foliage, blossom, fruit],
+        visible: [[blossom, () => heads.U.uFoliage.value > 0.001], [falling, () => mats.fall.userData.uniforms.uLeafFall.value + 0.6 * Math.max(0, Math.min(1, (u.uSeason.value - 0.5) * 2)) > 0.001]],
+    });
+    const cfg = Object.assign({}, c);
+    if (sp.flowersAlways !== undefined && (c.flowers ?? 0) === 0)
+        cfg.flowers = sp.flowersAlways;
+    if (sp.foliageAlways !== undefined)
+        cfg.foliage = sp.foliageAlways;
+    applyConfig(u, cfg, mats);
+    lod.applied(cfg);
+    return {
+        object,
+        materials: [barkPair.material, leafPair.material, heads.pair.material, fruitPair.material, fallPair.material, lod.impostor.material],
+        apply: function (cfg) { applyConfig(u, cfg, mats); lod.applied(cfg); },
+        update: function (dt, camera, sunWorld, renderer) { updateCommon(u, object, camera, dt, sunWorld); lod.update(dt, renderer); },
+        lod,
+        stats: { branches: plant.branches.length, leaves: leaves.length, barkVerts: barkGeo.attributes.position.count },
+        dispose: function () {
+            barkGeo.dispose();
+            leafGeo.dispose();
+            fallGeo.dispose();
+            fruitGeo.dispose();
+            heads.geo.dispose();
+            lod.dispose();
+            for (const p of [barkPair, leafPair, heads.pair, fruitPair, fallPair]) {
+                p.material.dispose();
+                p.depth.dispose();
+            }
+        },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['species', 'trunkRatio', 'branchiness', 'droop', 'twist', 'density', 'quality', 'seed'];

package/dist/components/vegetation/core/vegetable.d.ts

@@ -0,0 +1,99 @@
+import * as THREE from 'three';
+export declare function createUniforms(): {
+    uTime: {
+        value: number;
+    };
+    uWindPhase: {
+        value: number;
+    };
+    uWindDir: {
+        value: THREE.Vector2;
+    };
+    uWindStrength: {
+        value: number;
+    };
+    uTurb: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+    uSway: {
+        value: number;
+    };
+    uFlutter: {
+        value: number;
+    };
+    uScale: {
+        value: THREE.Vector3;
+    };
+    uMean: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uShadeColor: {
+        value: THREE.Color;
+    };
+    uSeason: {
+        value: number;
+    };
+    uFoliage: {
+        value: number;
+    };
+    uLeafType: {
+        value: number;
+    };
+    uLeafSize: {
+        value: number;
+    };
+    uGrowth: {
+        value: number;
+    };
+    uSunDirView: {
+        value: THREE.Vector3;
+    };
+    uViewPos: {
+        value: THREE.Vector3;
+    };
+    uLodK: {
+        value: number;
+    };
+    uLodOrtho: {
+        value: number;
+    };
+    uLodBias: {
+        value: number;
+    };
+    uImpReady: {
+        value: number;
+    };
+    uBake: {
+        value: number;
+    };
+    uBakeView: {
+        value: THREE.Matrix3;
+    };
+    uBakeDepth: {
+        value: THREE.Vector2;
+    };
+};
+export declare function applyConfig(u: any, c: any, mats: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.MeshPhysicalMaterial[];
+    apply: (cfg: any) => void;
+    update: (dt: any, camera: any, sunWorld: any) => void;
+    stats: {
+        pieces: number;
+        verts: number;
+    };
+    dispose: () => void;
+};
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export declare const STRUCTURAL: string[];
+//# sourceMappingURL=vegetable.d.ts.map

package/dist/components/vegetation/core/vegetable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vegetable.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/vegetable.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAarC;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAyCzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAAuC,CAAC"}

package/dist/components/vegetation/core/vegetable.js

@@ -0,0 +1,76 @@
+// Emitted from Claude outputs/vegetation-lab/vegetable.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Vegetable — vegetation object (lab module). Engine: ./produce.mjs (shared with fruit).
+// Construction: one kind of vegetable, as a single piece or a pile resting on the ground: lathe
+// profiles with lobes, ribs, kernels, warts and eyes (tomato, pepper, pumpkin, carrot, corn,
+// cucumber, eggplant, broccoli, potato, onion), stems, calyxes, tops and husks as leaf cards, and a
+// skin that ripens between two colours with the kind's pattern and gloss. Size: the unit box.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_V, unitBounds, plantMesh } from '../vegetationCore.js';
+import { PRODUCE, buildPiece, produceMaterial, instancePieces, pilePlacement, applyKind } from '../produceCore.js';
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, mats) {
+    // the family's `color` is the skin tint here and `shadeColor` the greens (leaves, calyx, crown)
+    applyCommonConfig(u, Object.assign({}, c, { color: c.shadeColor, shadeColor: undefined }));
+    if (!mats)
+        return;
+    const o = mats.skin.userData.uniforms;
+    const P = PRODUCE[c.kind] || PRODUCE.tomato;
+    if (c.kind !== undefined)
+        applyKind(mats.skin, P);
+    if (c.ripeness !== undefined)
+        o.uRipeness.value = c.ripeness;
+    if (c.sizeVar !== undefined)
+        o.uSizeVar.value = c.sizeVar;
+    if (c.blemish !== undefined)
+        o.uBlemish.value = c.blemish;
+    if (c.gloss !== undefined)
+        o.uGloss.value = P.gloss * c.gloss;
+    if (c.color !== undefined)
+        setColor(o.uTint, c.color);
+    if (c.count !== undefined)
+        o.uCount.value = c.count;
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const kind = PRODUCE[c.kind] ? c.kind : 'tomato';
+    const P = PRODUCE[kind];
+    const rnd = mulberry32((c.seed ?? 5) * 2654435761 + 5);
+    const count = Math.max(1, Math.round(c.count ?? 1));
+    let pair_setPieceH = 1;
+    const piece = buildPiece(kind, c.seed ?? 5, Math.min(1.6, 0.8 + 0.5 * q));
+    // fit: a single piece fills the box; a pile's footprint does
+    const ext = Math.max(piece.height, piece.width);
+    const foot = count <= 1 ? 1 : Math.min(0.5, 0.82 / Math.sqrt(count)) * (P.small ? 1.15 : 1);
+    const s = foot / ext;
+    piece.geo.scale(s, s, s);
+    const geo = instancePieces(piece.geo, count);
+    // lying kinds (carrot, banana, corn, cucumber) take their length as footprint and rest on their side
+    const foot2 = P.lie ? piece.height * s : piece.width * s;
+    const places = pilePlacement(count, foot2, rnd, count <= 1 || !!P.invert || !!P.crown || !!P.tops || !!P.mushroom || !!P.wrap, !!P.lie, piece.width * s * 0.5);
+    pair_setPieceH = piece.height * s;
+    for (let i = 0; i < count; i++) {
+        const p = places[i] || places[0];
+        geo.attributes.aXf.setXYZW(i, p.x, p.y, p.z, p.yaw);
+        geo.attributes.aTilt.setXYZW(i, p.tiltX, p.tiltZ, p.tilt, 1);
+        geo.attributes.aPiece.setXYZW(i, rnd(), i / count, rnd(), 0);
+    }
+    unitBounds(geo);
+    const pair = produceMaterial(u);
+    pair.material.userData.uniforms.uPieceH.value = pair_setPieceH;
+    const mesh = plantMesh(geo, pair, 'vegetable');
+    const object = new THREE.Group();
+    object.name = 'vegetable';
+    object.add(mesh);
+    const mats = { skin: pair.material };
+    applyConfig(u, c, mats);
+    return {
+        object,
+        materials: [pair.material],
+        apply: function (cfg) { applyConfig(u, cfg, mats); },
+        update: function (dt, camera, sunWorld) { updateCommon(u, object, camera, dt, sunWorld); },
+        stats: { pieces: count, verts: piece.geo.attributes.position.count },
+        dispose: function () { geo.dispose(); piece.geo.dispose(); pair.material.dispose(); pair.depth.dispose(); },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['kind', 'count', 'quality', 'seed'];

package/dist/components/vegetation/index.d.ts

@@ -0,0 +1,23 @@
+export { useVegetationInstance } from './useVegetationInstance';
+export type { VegetationInstance, VegetationVariantProps, VegetationCore } from './useVegetationInstance';
+export type { VegetationTreeProps } from './VegetationTree';
+export { default as VegetationTree } from './VegetationTree';
+export type { VegetationBushProps } from './VegetationBush';
+export { default as VegetationBush } from './VegetationBush';
+export type { VegetationGrassProps } from './VegetationGrass';
+export { default as VegetationGrass } from './VegetationGrass';
+export type { VegetationFlowersProps } from './VegetationFlowers';
+export { default as VegetationFlowers } from './VegetationFlowers';
+export type { VegetationCropsProps } from './VegetationCrops';
+export { default as VegetationCrops } from './VegetationCrops';
+export type { VegetationIvyProps } from './VegetationIvy';
+export { default as VegetationIvy } from './VegetationIvy';
+export type { VegetationHedgeProps } from './VegetationHedge';
+export { default as VegetationHedge } from './VegetationHedge';
+export type { VegetationFruitProps } from './VegetationFruit';
+export { default as VegetationFruit } from './VegetationFruit';
+export type { VegetationVegetableProps } from './VegetationVegetable';
+export { default as VegetationVegetable } from './VegetationVegetable';
+export type { VegetationForestProps } from './VegetationForest';
+export { default as VegetationForest } from './VegetationForest';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/vegetation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/vegetation/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC1G,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/components/vegetation/index.js

@@ -0,0 +1,14 @@
+// Vegetation variants (type 'vegetation', config.type set). One line per variant, written by the integrator.
+// vegetationCore / produceCore are the family's own (imported by core/<key>.ts), not re-exported: their helper names
+// (mulberry32, …) would collide with other families' cores in the components barrel.
+export { useVegetationInstance } from './useVegetationInstance.js';
+export { default as VegetationTree } from './VegetationTree.js';
+export { default as VegetationBush } from './VegetationBush.js';
+export { default as VegetationGrass } from './VegetationGrass.js';
+export { default as VegetationFlowers } from './VegetationFlowers.js';
+export { default as VegetationCrops } from './VegetationCrops.js';
+export { default as VegetationIvy } from './VegetationIvy.js';
+export { default as VegetationHedge } from './VegetationHedge.js';
+export { default as VegetationFruit } from './VegetationFruit.js';
+export { default as VegetationVegetable } from './VegetationVegetable.js';
+export { default as VegetationForest } from './VegetationForest.js';