@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-6Q7RC2MK.cjs

@@ -0,0 +1,1418 @@
+'use strict';
+
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+
+// src/traits/BotanicalLotusTrait.ts
+function cloneDefaultConfig() {
+  const d = exports.DEFAULT_BOTANICAL_LOTUS_CONFIG;
+  return {
+    ...d,
+    source: { ...d.source },
+    reference_anchors: d.reference_anchors.map((a) => ({ ...a })),
+    material: {
+      ...d.material,
+      subsurface_radius_rgb: [...d.material.subsurface_radius_rgb]
+    },
+    colors: { ...d.colors },
+    geometry: {
+      ...d.geometry,
+      petal_rings: d.geometry.petal_rings.map((r) => ({ ...r }))
+    },
+    renderer: {
+      ...d.renderer,
+      requires: [...d.renderer.requires],
+      lod: { ...d.renderer.lod }
+    }
+  };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function addRangeError(errors, label, value, min, max) {
+  if (!isFiniteNumber(value) || value < min || value > max) {
+    errors.push(`${label} must be a finite number in [${min}, ${max}]`);
+  }
+}
+function validateHexColors(errors, colors) {
+  for (const [key, value] of Object.entries(colors)) {
+    if (!HEX_COLOR_PATTERN.test(value)) {
+      errors.push(`colors.${key} must be a 6-digit hex color`);
+    }
+  }
+}
+function validateReferenceAnchor(errors, anchor, index) {
+  const prefix = `reference_anchors[${index}]`;
+  if (!anchor.id || typeof anchor.id !== "string") {
+    errors.push(`${prefix}.id is required`);
+  }
+  if (!anchor.uri || typeof anchor.uri !== "string") {
+    errors.push(`${prefix}.uri is required`);
+  }
+  if (anchor.status !== "pending_media_ingest" && anchor.status !== "hashed" && anchor.status !== "wallet_signed") {
+    errors.push(`${prefix}.status must be pending_media_ingest, hashed, or wallet_signed`);
+  }
+  if (anchor.status !== "pending_media_ingest") {
+    if (!anchor.content_hash || !SHA256_HASH_PATTERN.test(anchor.content_hash)) {
+      errors.push(`${prefix}.content_hash must be sha256:<64 lowercase hex chars>`);
+    }
+  }
+  if (anchor.status === "wallet_signed" && !anchor.wallet_signature) {
+    errors.push(`${prefix}.wallet_signature is required when status is wallet_signed`);
+  }
+  if (anchor.width !== void 0 && (!Number.isInteger(anchor.width) || anchor.width <= 0)) {
+    errors.push(`${prefix}.width must be a positive integer when present`);
+  }
+  if (anchor.height !== void 0 && (!Number.isInteger(anchor.height) || anchor.height <= 0)) {
+    errors.push(`${prefix}.height must be a positive integer when present`);
+  }
+}
+function normalizeBotanicalLotusConfig(input = {}) {
+  const d = cloneDefaultConfig();
+  const inputGeometry = input.geometry ?? {};
+  const inputRenderer = input.renderer ?? {};
+  const petalRings = Array.isArray(inputGeometry.petal_rings) ? inputGeometry.petal_rings.map((r) => ({ ...r })) : d.geometry.petal_rings.map((r) => ({ ...r }));
+  return {
+    schema: input.schema ?? d.schema,
+    status: input.status ?? d.status,
+    source: {
+      ...d.source,
+      ...input.source ?? {}
+    },
+    reference_anchors: Array.isArray(input.reference_anchors) ? input.reference_anchors.map((a) => ({ ...a })) : d.reference_anchors,
+    material: {
+      ...d.material,
+      ...input.material ?? {},
+      subsurface_radius_rgb: [
+        ...input.material?.subsurface_radius_rgb ?? d.material.subsurface_radius_rgb
+      ]
+    },
+    colors: {
+      ...d.colors,
+      ...input.colors ?? {}
+    },
+    geometry: {
+      ...d.geometry,
+      ...inputGeometry,
+      petal_rings: petalRings
+    },
+    renderer: {
+      ...d.renderer,
+      ...inputRenderer,
+      requires: [...inputRenderer.requires ?? d.renderer.requires],
+      lod: {
+        ...d.renderer.lod,
+        ...inputRenderer.lod ?? {}
+      }
+    }
+  };
+}
+function validateBotanicalLotusConfig(input = {}) {
+  const config = normalizeBotanicalLotusConfig(input);
+  const errors = [];
+  const { material, geometry } = config;
+  if (config.schema !== "holoscript.trait.botanical_lotus.v0") {
+    errors.push("schema must be holoscript.trait.botanical_lotus.v0");
+  }
+  if (config.status !== "visual_seed" && config.status !== "content_hashed" && config.status !== "wallet_signed") {
+    errors.push("status must be visual_seed, content_hashed, or wallet_signed");
+  }
+  if (config.reference_anchors.length === 0) {
+    errors.push("reference_anchors must include at least one anchor");
+  }
+  config.reference_anchors.forEach(
+    (anchor, index) => validateReferenceAnchor(errors, anchor, index)
+  );
+  addRangeError(errors, "material.subsurface_scattering", material.subsurface_scattering, 0, 1);
+  if (material.subsurface_radius_rgb.length !== 3) {
+    errors.push("material.subsurface_radius_rgb must contain exactly three values");
+  }
+  material.subsurface_radius_rgb.forEach(
+    (value, index) => addRangeError(errors, `material.subsurface_radius_rgb[${index}]`, value, 0, 2)
+  );
+  addRangeError(
+    errors,
+    "material.petal_translucency_base",
+    material.petal_translucency_base,
+    0,
+    1
+  );
+  addRangeError(
+    errors,
+    "material.petal_translucency_edge",
+    material.petal_translucency_edge,
+    0,
+    1
+  );
+  addRangeError(errors, "material.roughness", material.roughness, 0, 1);
+  addRangeError(errors, "material.ior", material.ior, 1, 2.5);
+  addRangeError(
+    errors,
+    "material.vein_normal_intensity",
+    material.vein_normal_intensity,
+    0,
+    0.25
+  );
+  addRangeError(errors, "material.edge_curl_intensity", material.edge_curl_intensity, 0, 1);
+  addRangeError(errors, "material.gravity_sag_outer", material.gravity_sag_outer, 0, 1);
+  addRangeError(errors, "material.sheen", material.sheen, 0, 1);
+  addRangeError(errors, "material.sheen_roughness", material.sheen_roughness, 0, 1);
+  if (!HEX_COLOR_PATTERN.test(material.sheen_color)) {
+    errors.push("material.sheen_color must be a 6-digit hex color");
+  }
+  validateHexColors(errors, config.colors);
+  if (geometry.petal_rings.length === 0) {
+    errors.push("geometry.petal_rings must include at least one ring");
+  }
+  geometry.petal_rings.forEach((ring, index) => {
+    if (!ring.name) {
+      errors.push(`geometry.petal_rings[${index}].name is required`);
+    }
+    if (!Number.isInteger(ring.count) || ring.count <= 0) {
+      errors.push(`geometry.petal_rings[${index}].count must be a positive integer`);
+    }
+    addRangeError(errors, `geometry.petal_rings[${index}].cup`, ring.cup, 0, 1);
+    addRangeError(
+      errors,
+      `geometry.petal_rings[${index}].gravity_sag`,
+      ring.gravity_sag,
+      0,
+      1
+    );
+  });
+  if (!Number.isInteger(geometry.stamen_filament_count) || geometry.stamen_filament_count <= 0) {
+    errors.push("geometry.stamen_filament_count must be a positive integer");
+  }
+  if (config.renderer.requires.length === 0) {
+    errors.push("renderer.requires must include at least one render capability");
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    config
+  };
+}
+function assertBotanicalLotusConfig(input = {}) {
+  const result = validateBotanicalLotusConfig(input);
+  if (!result.ok) {
+    throw new Error(`Invalid botanical_lotus config: ${result.errors.join("; ")}`);
+  }
+  return result.config;
+}
+function deriveBotanicalLotusAnchorStatus(anchors) {
+  if (anchors.length > 0 && anchors.every((anchor) => anchor.status === "wallet_signed")) {
+    return "wallet_signed";
+  }
+  if (anchors.length > 0 && anchors.every((anchor) => anchor.status === "hashed" || anchor.status === "wallet_signed")) {
+    return "hashed";
+  }
+  return "pending_media_ingest";
+}
+function getBotanicalLotusPetalCount(input = {}) {
+  const config = normalizeBotanicalLotusConfig(input);
+  return config.geometry.petal_rings.reduce((sum, ring) => sum + ring.count, 0);
+}
+function createBotanicalLotusRenderProfile(input = {}, placement, lighting) {
+  const config = assertBotanicalLotusConfig(input);
+  const anchorStatus = deriveBotanicalLotusAnchorStatus(config.reference_anchors);
+  const petalRings = config.geometry.petal_rings.map((ring, index) => {
+    const base = RING_RENDER_DEFAULTS[ring.name] ?? {
+      radius: 0.42 + index * 0.24,
+      length: 0.82 + index * 0.2,
+      width: 0.34 + index * 0.08,
+      pitch_degrees: Math.max(12, 70 - index * 18)
+    };
+    return {
+      name: ring.name,
+      count: ring.count,
+      radius: base.radius,
+      length: base.length,
+      width: base.width,
+      cup: ring.cup,
+      gravity_sag: ring.gravity_sag,
+      pitch_degrees: base.pitch_degrees
+    };
+  });
+  return {
+    trait: "botanical_lotus",
+    anchor_status: anchorStatus,
+    wallet_signed: anchorStatus === "wallet_signed",
+    petal_count: petalRings.reduce((sum, ring) => sum + ring.count, 0),
+    petal_rings: petalRings,
+    pbr_uniforms: {
+      subsurface_scattering: config.material.subsurface_scattering,
+      subsurface_radius_rgb: config.material.subsurface_radius_rgb,
+      transmission: config.material.petal_translucency_base,
+      thickness: config.material.petal_translucency_edge,
+      roughness: config.material.roughness,
+      ior: config.material.ior,
+      vein_normal_intensity: config.material.vein_normal_intensity,
+      sheen: config.material.sheen,
+      sheen_roughness: config.material.sheen_roughness,
+      sheen_color: config.material.sheen_color
+    },
+    colors: config.colors,
+    stamen_filament_count: config.geometry.stamen_filament_count,
+    seed_pod_dot_pattern: config.geometry.seed_pod_dot_pattern,
+    reference_anchor_ids: config.reference_anchors.map((anchor) => anchor.id),
+    renderer_requires: config.renderer.requires,
+    surface_anchor_id: placement?.surface_anchor_id,
+    lighting_reference: lighting?.reference_id
+  };
+}
+function deriveLotusBloomFromGlow(intensity, pulse) {
+  if (intensity >= 1 && pulse) return "full";
+  if (intensity >= 0.7) return "blooming";
+  if (intensity >= 0.3) return "budding";
+  return "sealed";
+}
+function lotusPetalRenderColor(ring, isRoot, colors) {
+  if (isRoot) return colors.petal_base;
+  if (ring === 1) return colors.petal_inner;
+  if (ring === 2) return colors.petal_mid;
+  return exports.LOTUS_OUTER_PETAL_COLOR;
+}
+function lotusObjectTraitConfig(obj, name) {
+  return obj.traits?.find((t) => t.name === name)?.config;
+}
+function buildLotusSceneFromComposition(objects, profile = createBotanicalLotusRenderProfile(), options = {}) {
+  const ringProfile = /* @__PURE__ */ new Map();
+  profile.petal_rings.forEach((r, i) => ringProfile.set(i + 1, r));
+  const lastRing = profile.petal_rings[profile.petal_rings.length - 1];
+  const goldenAngle = exports.LOTUS_GOLDEN_ANGLE_DEG * Math.PI / 180;
+  const petalObjs = objects.filter((o) => LOTUS_PETAL_NAME_RE.test(String(o.name ?? "")));
+  const ringCounters = { 1: 0, 2: 0, 3: 0 };
+  const seedNum = Number(options.seed ?? exports.LOTUS_GENESIS_SEED_PLACEHOLDER) >>> 0;
+  const PHYLLOTAXIS_WARMUP = 60;
+  const phyllotaxis = simulateLotusPhyllotaxis({
+    count: petalObjs.length + PHYLLOTAXIS_WARMUP,
+    seed: seedNum
+  });
+  const grownAngles = phyllotaxis.primordia.slice(PHYLLOTAXIS_WARMUP).map((p) => p.theta);
+  const petals = petalObjs.map((obj, index) => {
+    const match = LOTUS_PETAL_NAME_RE.exec(String(obj.name));
+    const ring = Number(match?.[1] ?? 3);
+    const ringIndex = ringCounters[ring]++;
+    const glow = lotusObjectTraitConfig(obj, "glowing") ?? {};
+    const intensity = typeof glow.intensity === "number" ? glow.intensity : 0.1;
+    const pulse = glow.pulse === true;
+    const isRoot = index === 0;
+    const bloom = isRoot ? "full" : deriveLotusBloomFromGlow(intensity, pulse);
+    const base = ringProfile.get(ring) ?? lastRing;
+    const scale = exports.LOTUS_RING_SCALING[ring];
+    return {
+      index,
+      ring,
+      ringIndex,
+      angle: grownAngles[index] ?? index * goldenAngle,
+      radius: base.radius * scale.radius,
+      length: base.length * scale.length,
+      width: base.width * scale.width,
+      cup: base.cup,
+      gravitySag: base.gravity_sag,
+      height: scale.height,
+      color: lotusPetalRenderColor(ring, isRoot, profile.colors),
+      bloom,
+      label: `P${ring}.${ringIndex}`,
+      title: String(obj.name ?? `Petal P${ring}.${ringIndex}`)
+    };
+  });
+  const rings = [1, 2, 3].map((ring) => {
+    const base = ringProfile.get(ring) ?? lastRing;
+    const scale = exports.LOTUS_RING_SCALING[ring];
+    return {
+      ring,
+      count: base.count,
+      radius: base.radius * scale.radius,
+      length: base.length * scale.length,
+      width: base.width * scale.width,
+      cup: base.cup,
+      gravity_sag: base.gravity_sag,
+      height: scale.height
+    };
+  });
+  return {
+    seed: options.seed ?? exports.LOTUS_GENESIS_SEED_PLACEHOLDER,
+    golden_angle_deg: exports.LOTUS_GOLDEN_ANGLE_DEG,
+    growth_seconds: exports.LOTUS_GROWTH_SECONDS,
+    rings,
+    petals,
+    material: profile.pbr_uniforms,
+    colors: profile.colors,
+    stamen_filament_count: profile.stamen_filament_count,
+    seed_pod_dot_pattern: profile.seed_pod_dot_pattern
+  };
+}
+function hexToRgb01(hex) {
+  const h = hex.replace("#", "");
+  const r = parseInt(h.slice(0, 2), 16) / 255;
+  const g = parseInt(h.slice(2, 4), 16) / 255;
+  const b = parseInt(h.slice(4, 6), 16) / 255;
+  return [r, g, b];
+}
+function buildLotusPetalMaterialSpec(profile, options = {}) {
+  const pbr = profile.pbr_uniforms;
+  const colors = profile.colors;
+  const dyn = { ...LOTUS_PETAL_DEFAULT_DYNAMIC, ...options.dynamic };
+  const size = options.detailMapSize ?? 256;
+  const veinSeed = options.veinSeed ?? 57005;
+  const roughnessSeed = options.roughnessSeed ?? 45063;
+  const physical = {
+    color: colors.petal_base,
+    roughness: pbr.roughness,
+    metalness: 0,
+    transparent: true,
+    transmission: pbr.transmission,
+    thickness: pbr.thickness,
+    ior: pbr.ior,
+    sheen: pbr.sheen,
+    sheenColor: pbr.sheen_color,
+    sheenRoughness: pbr.sheen_roughness
+  };
+  const uniforms = {
+    // Static color uniforms (from the declared palette) — vec3 in 0..1.
+    uLotusBaseColor: { value: hexToRgb01(colors.petal_base) },
+    uLotusMidColor: { value: hexToRgb01(colors.petal_mid) },
+    uLotusRimColor: { value: hexToRgb01(colors.petal_rim) },
+    uLotusShadowColor: { value: hexToRgb01(colors.petal_shadow) },
+    // Subsurface scatter tint comes from the declared radius RGB (already 0..1).
+    uLotusSubsurfaceColor: { value: [...pbr.subsurface_radius_rgb] },
+    // Static scalar uniforms from the PBR profile.
+    uLotusSSS: { value: pbr.subsurface_scattering },
+    uLotusTransmissionBase: { value: pbr.transmission },
+    uLotusTransmissionEdge: { value: pbr.thickness },
+    uLotusVeinIntensity: { value: pbr.vein_normal_intensity },
+    // Dynamic uniforms (driven per-frame via LOTUS_PETAL_UNIFORM_BINDINGS).
+    uPetalDevTime: { value: dyn.devTime },
+    uPetalCurlScale: { value: dyn.curlScale },
+    uLotusGrowth: { value: dyn.growth },
+    uLotusBloom: { value: dyn.bloom },
+    uLotusTime: { value: dyn.time }
+  };
+  return {
+    physical,
+    shaderChunks: {
+      chunks: [...exports.LOTUS_PETAL_CHUNK_ENTRIES],
+      uniforms
+    },
+    proceduralMaps: {
+      normalMap: {
+        generator: "botanical_normal",
+        params: {
+          pattern: "petal_veins",
+          size,
+          seed: veinSeed,
+          strength: Math.max(0.5, pbr.vein_normal_intensity * 32)
+        }
+      },
+      roughnessMap: {
+        generator: "botanical_roughness",
+        params: { size, seed: roughnessSeed, base: pbr.roughness, variance: 0.3 }
+      }
+    }
+  };
+}
+function botMix(a, b, t) {
+  return a + (b - a) * t;
+}
+function botHash(ix, iy, seed) {
+  let h = Math.imul(ix, 374761393) + Math.imul(iy, 668265263) + Math.imul(seed, 1013904223) >>> 0;
+  h = Math.imul(h ^ h >>> 13, 1274126177) >>> 0;
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function botValueNoise(x, y, seed) {
+  const ix = Math.floor(x);
+  const iy = Math.floor(y);
+  const fx = x - ix;
+  const fy = y - iy;
+  const ux = fx * fx * (3 - 2 * fx);
+  const uy = fy * fy * (3 - 2 * fy);
+  const a = botHash(ix, iy, seed);
+  const b = botHash(ix + 1, iy, seed);
+  const c = botHash(ix, iy + 1, seed);
+  const d = botHash(ix + 1, iy + 1, seed);
+  return botMix(botMix(a, b, ux), botMix(c, d, ux), uy);
+}
+function botFbm(x, y, seed, octaves = 4) {
+  let amp = 0.5;
+  let freq = 1;
+  let sum = 0;
+  let norm = 0;
+  for (let i = 0; i < octaves; i += 1) {
+    sum += amp * botValueNoise(x * freq, y * freq, seed + i * 101);
+    norm += amp;
+    amp *= 0.5;
+    freq *= 2;
+  }
+  return sum / norm;
+}
+function botanicalSurfaceHeight(pattern, u, v, seed) {
+  const micro = botFbm(u * 26, v * 26, seed, 4);
+  if (pattern === "petal_veins") {
+    const sx = u * 2 - 1;
+    const major = Math.pow(1 - Math.abs(Math.sin((sx * 9 + v * 3.2) * Math.PI)), 8);
+    const secondary = Math.pow(1 - Math.abs(Math.sin((sx * 19 - v * 2) * Math.PI)), 16) * 0.5;
+    const ridge = Math.max(0, 1 - Math.abs(sx) * 3) * (0.4 + v * 0.3);
+    return micro * 0.28 + major * 0.46 + secondary * 0.2 + ridge * 0.4;
+  }
+  if (pattern === "leaf_radial") {
+    const cx = u * 2 - 1;
+    const cy = v * 2 - 1;
+    const ang = Math.atan2(cy, cx);
+    const rad = Math.min(1, Math.sqrt(cx * cx + cy * cy));
+    const veins = Math.pow(Math.abs(Math.sin(ang * 13)), 6) * (1 - rad);
+    const rings = Math.pow(Math.abs(Math.sin(rad * 22)), 4) * 0.3;
+    return micro * 0.34 + veins * 0.56 + rings;
+  }
+  if (pattern === "stalk_fiber") {
+    const fibers = Math.pow(Math.abs(Math.sin(u * Math.PI * 40)), 3) * 0.5 + Math.abs(Math.sin(u * Math.PI * 83)) * 0.18;
+    const grain = botFbm(u * 12, v * 64, seed, 3);
+    return micro * 0.2 + fibers * 0.5 + grain * 0.3;
+  }
+  return micro;
+}
+function generateBotanicalNormalMap(opts) {
+  const size = opts.size ?? 256;
+  const seed = (opts.seed ?? 57005) >>> 0;
+  const strength = opts.strength ?? 1.6;
+  const data = new Uint8Array(size * size * 4);
+  const inv = 1 / size;
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const u = x * inv;
+      const v = y * inv;
+      const hL = botanicalSurfaceHeight(opts.pattern, (x - 1 + size) % size * inv, v, seed);
+      const hR = botanicalSurfaceHeight(opts.pattern, (x + 1) % size * inv, v, seed);
+      const hD = botanicalSurfaceHeight(opts.pattern, u, (y - 1 + size) % size * inv, seed);
+      const hU = botanicalSurfaceHeight(opts.pattern, u, (y + 1) % size * inv, seed);
+      let nx = (hL - hR) * strength;
+      let ny = (hD - hU) * strength;
+      const nz = 1;
+      const len = Math.hypot(nx, ny, nz) || 1;
+      nx /= len;
+      ny /= len;
+      const i = (y * size + x) * 4;
+      data[i] = Math.round((nx * 0.5 + 0.5) * 255);
+      data[i + 1] = Math.round((ny * 0.5 + 0.5) * 255);
+      data[i + 2] = Math.round((nz / len * 0.5 + 0.5) * 255);
+      data[i + 3] = 255;
+    }
+  }
+  return { width: size, height: size, data };
+}
+function generateBotanicalRoughnessMap(opts) {
+  const size = opts.size ?? 256;
+  const seed = (opts.seed ?? 45063) >>> 0;
+  const base = opts.base ?? 0.6;
+  const variance = opts.variance ?? 0.3;
+  const scale = opts.scale ?? 10;
+  const data = new Uint8Array(size * size * 4);
+  const inv = 1 / size;
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const r = Math.min(
+        1,
+        Math.max(0, base + (botFbm(x * inv * scale, y * inv * scale, seed, 4) - 0.5) * 2 * variance)
+      );
+      const g = Math.round(r * 255);
+      const i = (y * size + x) * 4;
+      data[i] = g;
+      data[i + 1] = g;
+      data[i + 2] = g;
+      data[i + 3] = 255;
+    }
+  }
+  return { width: size, height: size, data };
+}
+function lotusMulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function simulateLotusMorphogenesis(params) {
+  const count = Math.max(1, Math.floor(params.count));
+  const seed = (params.seed ?? 57005) >>> 0;
+  const apexRadius = params.apexRadius ?? 1;
+  const radialVelocity = params.radialVelocity ?? 0.08;
+  const s = params.inhibitionExponent ?? 3;
+  const samples = params.angularSamples ?? 1440;
+  const rand = lotusMulberry32(seed);
+  const primordia = [];
+  const TWO_PI = Math.PI * 2;
+  for (let n = 0; n < count; n += 1) {
+    for (const p of primordia) p.r += radialVelocity;
+    let chosenTheta;
+    if (primordia.length === 0) {
+      chosenTheta = rand() * TWO_PI;
+    } else {
+      let bestInhibition = Infinity;
+      let bestTheta = 0;
+      for (let i = 0; i < samples; i += 1) {
+        const theta = i / samples * TWO_PI;
+        const x = apexRadius * Math.cos(theta);
+        const y = apexRadius * Math.sin(theta);
+        let inhibition = 0;
+        for (const p of primordia) {
+          const px = p.r * Math.cos(p.theta);
+          const py = p.r * Math.sin(p.theta);
+          const d = Math.hypot(x - px, y - py);
+          inhibition += 1 / Math.pow(Math.max(d, 1e-4), s);
+        }
+        if (inhibition < bestInhibition) {
+          bestInhibition = inhibition;
+          bestTheta = theta;
+        }
+      }
+      chosenTheta = bestTheta;
+    }
+    primordia.push({ index: n, r: apexRadius, theta: chosenTheta });
+  }
+  const transient = Math.min(5, Math.max(0, primordia.length - 2));
+  let sumCos = 0;
+  let sumSin = 0;
+  let nDelta = 0;
+  for (let i = transient + 1; i < primordia.length; i += 1) {
+    let delta = primordia[i].theta - primordia[i - 1].theta;
+    delta = (delta % TWO_PI + TWO_PI) % TWO_PI;
+    if (delta > Math.PI) delta = TWO_PI - delta;
+    sumCos += Math.cos(delta);
+    sumSin += Math.sin(delta);
+    nDelta += 1;
+  }
+  const meanDelta = nDelta > 0 ? Math.atan2(sumSin / nDelta, sumCos / nDelta) : 0;
+  const meanDeg = (meanDelta * 180 / Math.PI + 360) % 360;
+  const resultant = nDelta > 0 ? Math.hypot(sumCos / nDelta, sumSin / nDelta) : 1;
+  const spreadDeg = Math.sqrt(Math.max(0, -2 * Math.log(Math.min(1, resultant)))) * 180 / Math.PI;
+  return {
+    primordia,
+    emergentDivergenceDeg: meanDeg,
+    divergenceSpreadDeg: spreadDeg,
+    resolvedParams: { count, seed, apexRadius, radialVelocity, inhibitionExponent: s, angularSamples: samples }
+  };
+}
+function lotusInhibitionAt(theta, primordia, range, apexRadius) {
+  const x = apexRadius * Math.cos(theta);
+  const y = apexRadius * Math.sin(theta);
+  let sum = 0;
+  for (const p of primordia) {
+    const d = Math.hypot(x - p.r * Math.cos(p.theta), y - p.r * Math.sin(p.theta));
+    sum += Math.exp(-d / range);
+  }
+  return sum;
+}
+function createLotusMeristem(params) {
+  const seed = (params.seed ?? 57005) >>> 0;
+  const apexRadius = params.apexRadius ?? 1;
+  const v = params.radialVelocity ?? 0.025;
+  const range = params.inhibitorRange ?? 0.5;
+  const threshold = params.threshold ?? 1;
+  const [wMinDeg, wMaxDeg] = params.chiralWindowDeg ?? [80, 230];
+  const samples = params.angularSamples ?? 720;
+  const DEG = Math.PI / 180;
+  const wMin = wMinDeg * DEG;
+  const wMax = wMaxDeg * DEG;
+  const rand = lotusMulberry32(seed);
+  const last = rand() * Math.PI * 2;
+  return {
+    primordia: [{ index: 0, r: apexRadius, theta: last }],
+    last,
+    apexRadius,
+    v,
+    range,
+    threshold,
+    wMin,
+    wMax,
+    samples,
+    step: (wMax - wMin) / samples
+  };
+}
+function stepLotusMeristem(m) {
+  const TWO_PI = Math.PI * 2;
+  for (const p of m.primordia) p.r += m.v;
+  let bestK = 0;
+  let bestI = Infinity;
+  for (let k = 0; k <= m.samples; k += 1) {
+    const I = lotusInhibitionAt(m.last + m.wMin + m.step * k, m.primordia, m.range, m.apexRadius);
+    if (I < bestI) {
+      bestI = I;
+      bestK = k;
+    }
+  }
+  let off = bestK;
+  if (bestK > 0 && bestK < m.samples) {
+    const y0 = lotusInhibitionAt(m.last + m.wMin + m.step * (bestK - 1), m.primordia, m.range, m.apexRadius);
+    const y2 = lotusInhibitionAt(m.last + m.wMin + m.step * (bestK + 1), m.primordia, m.range, m.apexRadius);
+    const den = y0 - 2 * bestI + y2;
+    if (Math.abs(den) > 1e-12) off = bestK + 0.5 * (y0 - y2) / den;
+  }
+  if (bestI < m.threshold) {
+    const theta = m.last + m.wMin + m.step * off;
+    m.last = (theta % TWO_PI + TWO_PI) % TWO_PI;
+    m.primordia.push({ index: m.primordia.length, r: m.apexRadius, theta: m.last });
+    return true;
+  }
+  return false;
+}
+function simulateLotusPhyllotaxis(params) {
+  const count = Math.max(1, Math.floor(params.count));
+  const TWO_PI = Math.PI * 2;
+  const meristem = createLotusMeristem(params);
+  let guard = 0;
+  const guardMax = count * 2e5;
+  while (meristem.primordia.length < count && guard++ < guardMax) stepLotusMeristem(meristem);
+  const primordia = meristem.primordia;
+  const tailStart = Math.max(1, primordia.length - 30);
+  let sumCos = 0;
+  let sumSin = 0;
+  let nDelta = 0;
+  for (let i = tailStart; i < primordia.length; i += 1) {
+    let delta = primordia[i].theta - primordia[i - 1].theta;
+    delta = (delta % TWO_PI + TWO_PI) % TWO_PI;
+    if (delta > Math.PI) delta = TWO_PI - delta;
+    sumCos += Math.cos(delta);
+    sumSin += Math.sin(delta);
+    nDelta += 1;
+  }
+  const meanDelta = nDelta > 0 ? Math.atan2(sumSin / nDelta, sumCos / nDelta) : 0;
+  const emergentDivergenceDeg = (meanDelta * 180 / Math.PI + 360) % 360;
+  const resultant = nDelta > 0 ? Math.hypot(sumCos / nDelta, sumSin / nDelta) : 1;
+  const divergenceSpreadDeg = Math.sqrt(Math.max(0, -2 * Math.log(Math.min(1, resultant)))) * 180 / Math.PI;
+  return { primordia, emergentDivergenceDeg, divergenceSpreadDeg };
+}
+function lotusSmoothstep01(edge0, edge1, x) {
+  const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+  return t * t * (3 - 2 * t);
+}
+function simulateLotusPetalGrowth(params) {
+  const t = Math.max(0, Math.min(1, params.developmentalTime));
+  const budCurl = params.budCurl ?? 2.8;
+  const openCurl = params.openCurl ?? -0.25;
+  const matureStart = params.matureStart ?? 0.15;
+  const matureSpan = params.matureSpan ?? 0.5;
+  const acropetalDelay = params.acropetalDelay ?? 0.35;
+  const baseAngle = (params.baseAngleDeg ?? 90) * Math.PI / 180;
+  const N = Math.max(4, Math.floor(params.segments ?? 24));
+  let phi = baseAngle;
+  let x = 0;
+  let y = 0;
+  const centerline = [[0, 0]];
+  const curvature = [];
+  const ds = 1 / N;
+  for (let i = 0; i < N; i += 1) {
+    const s = (i + 0.5) / N;
+    const maturity = lotusSmoothstep01(0, 1, (t - matureStart - s * acropetalDelay) / matureSpan);
+    const kappa = budCurl * (1 - maturity) + openCurl * maturity;
+    curvature.push(kappa);
+    phi += kappa * ds;
+    x += Math.cos(phi) * ds;
+    y += Math.sin(phi) * ds;
+    centerline.push([x, y]);
+  }
+  const baseMaturity = lotusSmoothstep01(0, 1, (t - matureStart) / matureSpan);
+  const tipMaturity = lotusSmoothstep01(0, 1, (t - matureStart - acropetalDelay) / matureSpan);
+  return {
+    tipAngleDeg: phi * 180 / Math.PI,
+    centerline,
+    curvature,
+    baseMaturity,
+    tipMaturity
+  };
+}
+function createLotusPond(params = {}) {
+  const size = Math.max(8, Math.floor(params.size ?? 96));
+  const extent = params.extent ?? 4;
+  const c = params.waveSpeed ?? 2.2;
+  const damping = params.damping ?? 0.6;
+  const stalkRadius = params.stalkRadius ?? 0.09;
+  const capillaryLength = params.capillaryLength ?? 0.22;
+  const contactRise = params.contactRise ?? 0.05;
+  const dx = 2 * extent / size;
+  const n = size * size;
+  const h = new Float32Array(n);
+  const v = new Float32Array(n);
+  const meniscus = new Float32Array(n);
+  const mask = new Float32Array(n);
+  for (let j = 0; j < size; j += 1) {
+    for (let i = 0; i < size; i += 1) {
+      const wx = -extent + (i + 0.5) * dx;
+      const wz = -extent + (j + 0.5) * dx;
+      const r = Math.hypot(wx, wz);
+      const idx = j * size + i;
+      if (r <= stalkRadius) {
+        mask[idx] = 0;
+        meniscus[idx] = contactRise;
+      } else {
+        mask[idx] = 1;
+        meniscus[idx] = contactRise * Math.exp(-(r - stalkRadius) / capillaryLength);
+      }
+    }
+  }
+  return { size, extent, c, damping, dx, h, v, meniscus, mask };
+}
+function disturbLotusPond(state, worldX, worldZ, amplitude, radius = 0.15) {
+  const { size, extent, dx } = state;
+  const ci = (worldX + extent) / dx - 0.5;
+  const cj = (worldZ + extent) / dx - 0.5;
+  const rad = Math.max(1, radius / dx);
+  const i0 = Math.max(0, Math.floor(ci - rad * 3));
+  const i1 = Math.min(size - 1, Math.ceil(ci + rad * 3));
+  const j0 = Math.max(0, Math.floor(cj - rad * 3));
+  const j1 = Math.min(size - 1, Math.ceil(cj + rad * 3));
+  for (let j = j0; j <= j1; j += 1) {
+    for (let i = i0; i <= i1; i += 1) {
+      const d2 = (i - ci) * (i - ci) + (j - cj) * (j - cj);
+      const idx = j * size + i;
+      state.v[idx] += amplitude * Math.exp(-d2 / (2 * rad * rad)) * state.mask[idx];
+    }
+  }
+}
+function stepLotusPond(state, dt) {
+  const { size, c, damping, dx, h, v, mask } = state;
+  const cflDt = 0.6 * dx / Math.max(c, 1e-6);
+  const sub = Math.max(1, Math.min(8, Math.ceil(dt / cflDt)));
+  const subDt = dt / sub;
+  const c2 = c * c;
+  for (let step = 0; step < sub; step += 1) {
+    for (let j = 1; j < size - 1; j += 1) {
+      for (let i = 1; i < size - 1; i += 1) {
+        const idx = j * size + i;
+        if (mask[idx] === 0) {
+          v[idx] = 0;
+          h[idx] = 0;
+          continue;
+        }
+        const lap = (h[idx - 1] + h[idx + 1] + h[idx - size] + h[idx + size] - 4 * h[idx]) / (dx * dx);
+        v[idx] += (c2 * lap - damping * v[idx]) * subDt;
+      }
+    }
+    for (let k = 0; k < h.length; k += 1) h[k] += v[k] * subDt;
+  }
+}
+function lotusPondSurface(state, out) {
+  const n = state.h.length;
+  const surface = out && out.length === n ? out : new Float32Array(n);
+  for (let k = 0; k < n; k += 1) surface[k] = state.h[k] * state.mask[k] + state.meniscus[k];
+  return surface;
+}
+function createLotusMorphogen(params = {}) {
+  const size = Math.max(8, Math.floor(params.size ?? 96));
+  const d = params.diffusionRatio ?? 40;
+  const gamma = params.gamma ?? 800;
+  const a = params.a ?? 0.1;
+  const b = params.b ?? 0.9;
+  const seed = (params.seed ?? 57005) >>> 0;
+  const dx = 1 / size;
+  const dt = 0.4 * (dx * dx) / Math.max(1, d);
+  const us = a + b;
+  const vs = b / (us * us);
+  const rand = lotusMulberry32(seed);
+  const u = new Float32Array(size);
+  const v = new Float32Array(size);
+  for (let i = 0; i < size; i += 1) {
+    u[i] = us + 0.05 * (rand() - 0.5);
+    v[i] = vs + 0.05 * (rand() - 0.5);
+  }
+  return { size, d, gamma, a, b, dt, u, v };
+}
+function stepLotusMorphogen(field, iterations = 1) {
+  const { size, d, gamma, a, b, dt, u, v } = field;
+  const dx2 = 1 / size * (1 / size);
+  const lu = new Float32Array(size);
+  const lv = new Float32Array(size);
+  for (let it = 0; it < iterations; it += 1) {
+    for (let i = 0; i < size; i += 1) {
+      const ip = (i + 1) % size;
+      const im = (i - 1 + size) % size;
+      lu[i] = (u[im] - 2 * u[i] + u[ip]) / dx2;
+      lv[i] = (v[im] - 2 * v[i] + v[ip]) / dx2;
+    }
+    for (let i = 0; i < size; i += 1) {
+      const uv = u[i] * u[i] * v[i];
+      u[i] += dt * (lu[i] + gamma * (a - u[i] + uv));
+      v[i] += dt * (d * lv[i] + gamma * (b - uv));
+    }
+  }
+}
+function lotusMorphogenPeaks(field) {
+  const { size, u } = field;
+  let mn = Infinity;
+  let mx = -Infinity;
+  for (let i = 0; i < size; i += 1) {
+    if (u[i] < mn) mn = u[i];
+    if (u[i] > mx) mx = u[i];
+  }
+  const thr = (mn + mx) / 2;
+  let peaks = 0;
+  for (let i = 0; i < size; i += 1) {
+    const ip = (i + 1) % size;
+    const im = (i - 1 + size) % size;
+    if (u[i] > thr && u[i] >= u[ip] && u[i] > u[im]) peaks += 1;
+  }
+  return peaks;
+}
+function createLotusMorphogen2D(params = {}) {
+  const size = Math.max(8, Math.floor(params.size ?? 64));
+  const d = params.diffusionRatio ?? 40;
+  const gamma = params.gamma ?? 1600;
+  const a = params.a ?? 0.1;
+  const b = params.b ?? 0.9;
+  const seed = (params.seed ?? 57005) >>> 0;
+  const dx = 1 / size;
+  const dt = 0.2 * (dx * dx) / Math.max(1, d);
+  const us = a + b;
+  const vs = b / (us * us);
+  const rand = lotusMulberry32(seed);
+  const n = size * size;
+  const u = new Float32Array(n);
+  const v = new Float32Array(n);
+  const mask = new Uint8Array(n);
+  const c = (size - 1) / 2;
+  for (let j = 0; j < size; j += 1) {
+    for (let i = 0; i < size; i += 1) {
+      const k = j * size + i;
+      const nx = (i - c) / c;
+      const ny = (j - c) / c;
+      const inside = nx * nx + ny * ny <= 1 ? 1 : 0;
+      mask[k] = inside;
+      u[k] = us + (inside ? 0.05 * (rand() - 0.5) : 0);
+      v[k] = vs;
+    }
+  }
+  return { size, d, gamma, a, b, dt, u, v, mask };
+}
+function stepLotusMorphogen2D(field, iterations = 1) {
+  const { size, d, gamma, a, b, dt, u, v, mask } = field;
+  const dx2 = 1 / size * (1 / size);
+  const n = size * size;
+  const lu = new Float32Array(n);
+  const lv = new Float32Array(n);
+  for (let it = 0; it < iterations; it += 1) {
+    for (let j = 0; j < size; j += 1) {
+      for (let i = 0; i < size; i += 1) {
+        const k = j * size + i;
+        if (!mask[k]) continue;
+        const left = i > 0 && mask[k - 1] ? u[k - 1] : u[k];
+        const right = i < size - 1 && mask[k + 1] ? u[k + 1] : u[k];
+        const up = j > 0 && mask[k - size] ? u[k - size] : u[k];
+        const down = j < size - 1 && mask[k + size] ? u[k + size] : u[k];
+        const leftV = i > 0 && mask[k - 1] ? v[k - 1] : v[k];
+        const rightV = i < size - 1 && mask[k + 1] ? v[k + 1] : v[k];
+        const upV = j > 0 && mask[k - size] ? v[k - size] : v[k];
+        const downV = j < size - 1 && mask[k + size] ? v[k + size] : v[k];
+        lu[k] = (left + right + up + down - 4 * u[k]) / dx2;
+        lv[k] = (leftV + rightV + upV + downV - 4 * v[k]) / dx2;
+      }
+    }
+    for (let k = 0; k < n; k += 1) {
+      if (!mask[k]) continue;
+      const uv = u[k] * u[k] * v[k];
+      u[k] += dt * (lu[k] + gamma * (a - u[k] + uv));
+      v[k] += dt * (d * lv[k] + gamma * (b - uv));
+    }
+  }
+}
+function lotusMorphogen2DPeaks(field) {
+  const { size, u, mask } = field;
+  let mn = Infinity;
+  let mx = -Infinity;
+  for (let k = 0; k < u.length; k += 1) {
+    if (!mask[k]) continue;
+    if (u[k] < mn) mn = u[k];
+    if (u[k] > mx) mx = u[k];
+  }
+  const range = mx - mn || 1;
+  const thr = (mn + mx) / 2;
+  const c = (size - 1) / 2;
+  const peaks = [];
+  for (let j = 0; j < size; j += 1) {
+    for (let i = 0; i < size; i += 1) {
+      const k = j * size + i;
+      if (!mask[k] || u[k] <= thr) continue;
+      let isMax = true;
+      for (let dj = -1; dj <= 1 && isMax; dj += 1) {
+        for (let di = -1; di <= 1; di += 1) {
+          if (di === 0 && dj === 0) continue;
+          const ni = i + di;
+          const nj = j + dj;
+          if (ni < 0 || ni >= size || nj < 0 || nj >= size) continue;
+          const nk = nj * size + ni;
+          if (mask[nk] && u[nk] > u[k]) {
+            isMax = false;
+            break;
+          }
+        }
+      }
+      if (!isMax) continue;
+      const x = (i - c) / c;
+      const y = (j - c) / c;
+      peaks.push({
+        x,
+        y,
+        radius: Math.min(1, Math.hypot(x, y)),
+        angle: Math.atan2(y, x),
+        value: (u[k] - mn) / range
+      });
+    }
+  }
+  return peaks;
+}
+function lotusMorphogen2DSampleAt(field, x, y) {
+  const { size, u, mask } = field;
+  const c = (size - 1) / 2;
+  const i = Math.round(x * c + c);
+  const j = Math.round(y * c + c);
+  if (i < 0 || i >= size || j < 0 || j >= size) return 0;
+  const k = j * size + i;
+  if (!mask[k]) return 0;
+  let mn = Infinity;
+  let mx = -Infinity;
+  for (let m = 0; m < u.length; m += 1) {
+    if (!mask[m]) continue;
+    if (u[m] < mn) mn = u[m];
+    if (u[m] > mx) mx = u[m];
+  }
+  return (u[k] - mn) / (mx - mn || 1);
+}
+function createLotusPetalTurgor(params = {}) {
+  const segments = Math.max(4, Math.floor(params.segments ?? 24));
+  const budCurl = params.budCurl ?? 2.8;
+  const kappaActual = new Float32Array(segments).fill(budCurl);
+  return {
+    segments,
+    baseAngle: (params.baseAngleDeg ?? 90) * Math.PI / 180,
+    budCurl,
+    openCurl: params.openCurl ?? -0.25,
+    matureStart: params.matureStart ?? 0.15,
+    matureSpan: params.matureSpan ?? 0.5,
+    acropetalDelay: params.acropetalDelay ?? 0.35,
+    turgorStiffness: params.turgorStiffness ?? 6,
+    turgorRise: params.turgorRise ?? 3,
+    turgor: 0,
+    kappaActual
+  };
+}
+function stepLotusPetalTurgor(state, dt, developmentalTime) {
+  const t = Math.max(0, Math.min(1, developmentalTime));
+  const baseMaturity = lotusSmoothstep01(0, 1, (t - state.matureStart) / state.matureSpan);
+  state.turgor += state.turgorRise * (baseMaturity - state.turgor) * dt;
+  state.turgor = Math.max(0, Math.min(1, state.turgor));
+  const rate = state.turgorStiffness * state.turgor * dt;
+  for (let i = 0; i < state.segments; i += 1) {
+    const s = (i + 0.5) / state.segments;
+    const maturity = lotusSmoothstep01(0, 1, (t - state.matureStart - s * state.acropetalDelay) / state.matureSpan);
+    const kappaRest = state.budCurl * (1 - maturity) + state.openCurl * maturity;
+    state.kappaActual[i] += rate * (kappaRest - state.kappaActual[i]);
+  }
+}
+function lotusPetalTurgorTipDeg(state) {
+  let phi = state.baseAngle;
+  const ds = 1 / state.segments;
+  for (let i = 0; i < state.segments; i += 1) phi += state.kappaActual[i] * ds;
+  return phi * 180 / Math.PI;
+}
+function lotusPetalTurgorOpenProgress(state) {
+  const tip = lotusPetalTurgorTipDeg(state);
+  return Math.max(0, Math.min(1, (250 - tip) / (250 - 76)));
+}
+exports.DEFAULT_BOTANICAL_LOTUS_CONFIG = void 0; var SHA256_HASH_PATTERN, HEX_COLOR_PATTERN, RING_RENDER_DEFAULTS; exports.botanicalLotusHandler = void 0; exports.LOTUS_GOLDEN_ANGLE_DEG = void 0; exports.LOTUS_GROWTH_SECONDS = void 0; exports.LOTUS_GENESIS_SEED_PLACEHOLDER = void 0; exports.LOTUS_RING_SCALING = void 0; exports.LOTUS_OUTER_PETAL_COLOR = void 0; var LOTUS_PETAL_NAME_RE; exports.LOTUS_PETAL_SHADER_CHUNKS = void 0; exports.LOTUS_PETAL_CHUNK_ENTRIES = void 0; var LOTUS_PETAL_DEFAULT_DYNAMIC; exports.LOTUS_PETAL_UNIFORM_BINDINGS = void 0;
+var init_BotanicalLotusTrait = chunkHCCQLAA4_cjs.__esm({
+  "src/traits/BotanicalLotusTrait.ts"() {
+    exports.DEFAULT_BOTANICAL_LOTUS_CONFIG = {
+      schema: "holoscript.trait.botanical_lotus.v0",
+      status: "visual_seed",
+      source: {
+        kind: "conversation_reference_images",
+        count: 3,
+        content_hash_status: "pending_media_ingest",
+        wallet_signature_status: "pending_cael_anchor",
+        note: "Derived from three pink lotus reference images provided in-thread; raw media ingest is pending."
+      },
+      reference_anchors: [
+        {
+          id: "lotus-reference-2026-05-06-01",
+          label: "open pink lotus close-up",
+          uri: "conversation://2026-05-06/lotus-reference-01",
+          role: "material",
+          status: "pending_media_ingest"
+        },
+        {
+          id: "lotus-reference-2026-05-06-02",
+          label: "upright pink lotus silhouette",
+          uri: "conversation://2026-05-06/lotus-reference-02",
+          role: "silhouette",
+          status: "pending_media_ingest"
+        },
+        {
+          id: "lotus-reference-2026-05-06-03",
+          label: "pink lotus with leaves and water context",
+          uri: "conversation://2026-05-06/lotus-reference-03",
+          role: "leaf_context",
+          status: "pending_media_ingest"
+        }
+      ],
+      material: {
+        subsurface_scattering: 0.74,
+        subsurface_radius_rgb: [0.9, 0.32, 0.72],
+        petal_translucency_base: 0.68,
+        petal_translucency_edge: 0.36,
+        roughness: 0.72,
+        ior: 1.36,
+        vein_normal_intensity: 0.045,
+        edge_curl_intensity: 0.58,
+        gravity_sag_outer: 0.3,
+        sheen: 0.5,
+        sheen_roughness: 0.42,
+        sheen_color: "#ffe8f2"
+      },
+      colors: {
+        petal_base: "#fff1f6",
+        petal_mid: "#f47ab7",
+        petal_inner: "#ff9ecf",
+        petal_rim: "#c42a86",
+        petal_shadow: "#84205f",
+        seed_pod: "#f4d74a",
+        seed_pod_rim: "#b7c66b",
+        stamen: "#f59e0b",
+        stamen_tip: "#fff4bd",
+        leaf: "#235f4f",
+        leaf_dark: "#102f28",
+        water: "#07140f"
+      },
+      geometry: {
+        petal_rings: [
+          { name: "inner", count: 8, cup: 0.86, gravity_sag: 0.02 },
+          { name: "mid", count: 13, cup: 0.5, gravity_sag: 0.12 },
+          { name: "outer", count: 21, cup: 0.24, gravity_sag: 0.3 }
+        ],
+        petal_shape: "broad_elliptic_pointed_tip_with_center_ridge",
+        stamen_filament_count: 58,
+        seed_pod_dot_pattern: "1_center_7_12_18_radial"
+      },
+      renderer: {
+        requires: ["sss_render", "instanced_filaments", "water_surface"],
+        lod: {
+          close: "full_filaments",
+          mid: "simplified_filaments",
+          far: "petal_billboard"
+        },
+        material_model: "thin_tissue_mesh_physical_material"
+      }
+    };
+    SHA256_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+    HEX_COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+    RING_RENDER_DEFAULTS = {
+      inner: { radius: 0.32, length: 0.82, width: 0.34, pitch_degrees: 74 },
+      mid: { radius: 0.58, length: 1.15, width: 0.46, pitch_degrees: 42 },
+      outer: { radius: 0.92, length: 1.52, width: 0.58, pitch_degrees: 18 }
+    };
+    exports.botanicalLotusHandler = {
+      name: "botanical_lotus",
+      defaultConfig: exports.DEFAULT_BOTANICAL_LOTUS_CONFIG,
+      validate: validateBotanicalLotusConfig,
+      toRenderProfile: createBotanicalLotusRenderProfile,
+      onAttach(node, config, context) {
+        const normalized = assertBotanicalLotusConfig(config);
+        const profile = createBotanicalLotusRenderProfile(normalized);
+        const state = { config: normalized, profile };
+        node.__botanicalLotusState = state;
+        const nodeId = String(node.id ?? "unknown");
+        context.setState?.({
+          [`botanical_lotus.${nodeId}.anchor_status`]: profile.anchor_status,
+          [`botanical_lotus.${nodeId}.petal_count`]: profile.petal_count
+        });
+        context.emit?.("botanical_lotus_attached", {
+          node,
+          anchorStatus: profile.anchor_status,
+          walletSigned: profile.wallet_signed,
+          petalCount: profile.petal_count,
+          referenceAnchorIds: profile.reference_anchor_ids,
+          rendererRequires: profile.renderer_requires
+        });
+      },
+      onDetach(node, _config, context) {
+        context.emit?.("botanical_lotus_detached", { node });
+        delete node.__botanicalLotusState;
+      },
+      onUpdate(_node, _config, _context, _delta) {
+      },
+      onEvent(node, _config, context, event) {
+        const state = node.__botanicalLotusState;
+        if (!state) return;
+        if (event.type === "botanical_lotus_query") {
+          context.emit?.("botanical_lotus_response", {
+            queryId: event.queryId,
+            node,
+            config: state.config,
+            profile: state.profile
+          });
+          return;
+        }
+        if (event.type === "botanical_lotus_reference_anchored") {
+          const anchorId = String(event.anchorId ?? "");
+          const contentHash = typeof event.contentHash === "string" ? event.contentHash : void 0;
+          const walletSignature = typeof event.walletSignature === "string" ? event.walletSignature : void 0;
+          if (!anchorId || !contentHash) return;
+          const updatedAnchors = state.config.reference_anchors.map((anchor) => {
+            if (anchor.id !== anchorId) return anchor;
+            return {
+              ...anchor,
+              content_hash: contentHash,
+              wallet_signature: walletSignature,
+              status: walletSignature ? "wallet_signed" : "hashed"
+            };
+          });
+          const updatedConfig = assertBotanicalLotusConfig({
+            ...state.config,
+            status: updatedAnchors.every((anchor) => anchor.status === "wallet_signed") ? "wallet_signed" : "content_hashed",
+            source: {
+              ...state.config.source,
+              content_hash_status: deriveBotanicalLotusAnchorStatus(updatedAnchors),
+              wallet_signature_status: updatedAnchors.every(
+                (anchor) => anchor.status === "wallet_signed"
+              ) ? "wallet_signed" : "pending_cael_anchor"
+            },
+            reference_anchors: updatedAnchors
+          });
+          state.config = updatedConfig;
+          state.profile = createBotanicalLotusRenderProfile(updatedConfig, state.placement, state.lighting);
+          context.emit?.("botanical_lotus_reference_updated", {
+            node,
+            anchorId,
+            anchorStatus: state.profile.anchor_status,
+            walletSigned: state.profile.wallet_signed,
+            referenceAnchorIds: state.profile.reference_anchor_ids
+          });
+          return;
+        }
+        if (event.type === "holomap:surface_anchor_placed") {
+          const payload = event.payload ?? {};
+          const surfaceAnchorId = typeof payload.surfaceAnchorId === "string" ? payload.surfaceAnchorId : void 0;
+          const surfaceNormal = Array.isArray(payload.surfaceNormal) ? payload.surfaceNormal : void 0;
+          const worldPosition = Array.isArray(payload.worldPosition) ? payload.worldPosition : void 0;
+          if (!surfaceAnchorId) return;
+          state.placement = {
+            surface_anchor_id: surfaceAnchorId,
+            surface_normal: surfaceNormal,
+            world_position: worldPosition
+          };
+          state.profile = createBotanicalLotusRenderProfile(state.config, state.placement, state.lighting);
+          context.emit?.("botanical_lotus_surface_bound", {
+            node,
+            surfaceAnchorId,
+            surfaceNormal,
+            worldPosition
+          });
+          return;
+        }
+        if (event.type === "holomap:lighting_update") {
+          const payload = event.payload ?? {};
+          const referenceId = typeof payload.referenceId === "string" ? payload.referenceId : void 0;
+          const estimatedLux = typeof payload.estimatedLux === "number" && Number.isFinite(payload.estimatedLux) ? payload.estimatedLux : void 0;
+          const colorTemperatureK = typeof payload.colorTemperatureK === "number" && Number.isFinite(payload.colorTemperatureK) ? payload.colorTemperatureK : void 0;
+          const dominantDirection = Array.isArray(payload.dominantDirection) ? payload.dominantDirection : void 0;
+          if (!referenceId) return;
+          state.lighting = {
+            reference_id: referenceId,
+            estimated_lux: estimatedLux,
+            color_temperature_k: colorTemperatureK,
+            dominant_direction: dominantDirection
+          };
+          state.profile = createBotanicalLotusRenderProfile(state.config, state.placement, state.lighting);
+          context.emit?.("botanical_lotus_lighting_updated", {
+            node,
+            referenceId,
+            estimatedLux,
+            colorTemperatureK,
+            dominantDirection
+          });
+          return;
+        }
+        if (event.type === "holomap:anchor_state_changed") {
+          const payload = event.payload ?? {};
+          const anchorFrameIndex = typeof payload.anchorFrameIndex === "number" ? payload.anchorFrameIndex : void 0;
+          if (state.placement?.surface_anchor_id && anchorFrameIndex !== void 0) {
+            context.emit?.("botanical_lotus_anchor_drift", {
+              node,
+              surfaceAnchorId: state.placement.surface_anchor_id,
+              anchorFrameIndex
+            });
+          }
+          return;
+        }
+      }
+    };
+    exports.LOTUS_GOLDEN_ANGLE_DEG = 137.50776;
+    exports.LOTUS_GROWTH_SECONDS = 12.5;
+    exports.LOTUS_GENESIS_SEED_PLACEHOLDER = "0x0000DEAD";
+    exports.LOTUS_RING_SCALING = {
+      1: { radius: 1.25, length: 0.98, width: 1.65, height: 1.12 },
+      2: { radius: 1.25, length: 0.94, width: 1.48, height: 0.98 },
+      3: { radius: 1.25, length: 0.82, width: 1.35, height: 0.78 }
+    };
+    exports.LOTUS_OUTER_PETAL_COLOR = "#d94b9a";
+    LOTUS_PETAL_NAME_RE = /^Petal\s+P([123])\.(\d+)/;
+    exports.LOTUS_PETAL_SHADER_CHUNKS = {
+      /** Spliced after `#include <common>` in the vertex shader. */
+      vertexHeader: `
+attribute vec2 petalUv;
+attribute float veinPhase;
+varying vec2 vLotusPetalUv;
+varying float vLotusVeinPhase;
+varying vec3 vLotusWorldNormal;
+varying vec3 vLotusViewDir;
+uniform float uPetalDevTime;
+uniform float uPetalCurlScale;
+`,
+      /**
+       * Spliced after \`#include <begin_vertex>\` — EMERGENT petal curl (L2). Bends the
+       * length axis by the integral of the maturation-front growth curvature (mirrors
+       * simulateLotusPetalGrowth), RELATIVE to the fully-open state so the bend is zero at
+       * full bloom (the approved open pose is preserved exactly) and the bud-wrap appears
+       * only while opening. Curvature reverses inward(bud) -> outward(open) behind the
+       * acropetal maturation front.
+       */
+      vertexBend: `
+{
+  float lotusVlen = clamp(petalUv.y, 0.0, 1.0);
+  float lotusDs = lotusVlen / 12.0;
+  float lotusPhiN = 0.0, lotusPhiO = 0.0;
+  vec2 lotusCN = vec2(0.0), lotusCO = vec2(0.0);
+  for (int k = 0; k < 12; k++) {
+    float s = (float(k) + 0.5) * lotusDs;
+    float matN = smoothstep(0.0, 1.0, (uPetalDevTime - 0.15 - s * 0.35) / 0.5);
+    float matO = smoothstep(0.0, 1.0, (1.0 - 0.15 - s * 0.35) / 0.5);
+    lotusPhiN += mix(2.8, -0.25, matN) * lotusDs;
+    lotusPhiO += mix(2.8, -0.25, matO) * lotusDs;
+    lotusCN += vec2(cos(lotusPhiN), sin(lotusPhiN)) * lotusDs;
+    lotusCO += vec2(cos(lotusPhiO), sin(lotusPhiO)) * lotusDs;
+  }
+  vec2 lotusBend = (lotusCN - lotusCO) * uPetalCurlScale;
+  transformed.x += lotusBend.x;
+  transformed.y += lotusBend.y;
+}
+`,
+      /** Spliced after \`#include <worldpos_vertex>\`. */
+      vertexWorld: `
+vLotusPetalUv = petalUv;
+vLotusVeinPhase = veinPhase;
+vLotusWorldNormal = normalize(mat3(modelMatrix) * objectNormal);
+vLotusViewDir = normalize(cameraPosition - worldPosition.xyz);
+`,
+      /** Spliced after `#include <common>` in the fragment shader. */
+      fragmentHeader: `
+uniform vec3 uLotusBaseColor;
+uniform vec3 uLotusMidColor;
+uniform vec3 uLotusRimColor;
+uniform vec3 uLotusShadowColor;
+uniform vec3 uLotusSubsurfaceColor;
+uniform float uLotusSSS;
+uniform float uLotusTransmissionBase;
+uniform float uLotusTransmissionEdge;
+uniform float uLotusVeinIntensity;
+uniform float uLotusGrowth;
+uniform float uLotusBloom;
+uniform float uLotusTime;
+varying vec2 vLotusPetalUv;
+varying float vLotusVeinPhase;
+varying vec3 vLotusWorldNormal;
+varying vec3 vLotusViewDir;
+
+float lotusVeinField(vec2 uv, float phase) {
+  float signedX = uv.x * 2.0 - 1.0;
+  float major = pow(1.0 - abs(sin((signedX * 18.0 + uv.y * 6.0 + phase) * 3.14159265)), 20.0);
+  float secondary = pow(1.0 - abs(sin((signedX * 34.0 - uv.y * 4.0 - phase * 0.7) * 3.14159265)), 32.0);
+  float taper = (1.0 - smoothstep(0.82, 1.0, uv.y)) * (1.0 - abs(signedX) * 0.34);
+  return clamp((major * 0.62 + secondary * 0.38) * taper, 0.0, 1.0);
+}
+`,
+      /** Spliced after `#include <normal_fragment_maps>` — vein normal perturbation. */
+      fragmentNormalInjection: `
+float lotusNormalVein = lotusVeinField(vLotusPetalUv, vLotusVeinPhase);
+float lotusVeinSide = sign(vLotusPetalUv.x - 0.5);
+normal = normalize(normal + vec3(
+  lotusNormalVein * lotusVeinSide * uLotusVeinIntensity * 1.7,
+  lotusNormalVein * uLotusVeinIntensity * 0.6,
+  0.0
+));`,
+      /** Spliced after `#include <color_fragment>` — petal profile gradient + veins. */
+      fragmentColorInjection: `
+float lotusEdge = abs(vLotusPetalUv.x * 2.0 - 1.0);
+float lotusTip = smoothstep(0.78, 1.0, vLotusPetalUv.y);
+vec3 lotusProfileColor = mix(uLotusBaseColor, uLotusMidColor, smoothstep(0.08, 0.72, vLotusPetalUv.y));
+lotusProfileColor = mix(lotusProfileColor, uLotusRimColor, clamp(lotusEdge * lotusEdge * 0.42 + lotusTip * 0.35, 0.0, 0.82));
+float lotusVeinColorField = lotusVeinField(vLotusPetalUv, vLotusVeinPhase);
+vec3 lotusVeinColor = mix(uLotusShadowColor, uLotusRimColor, 0.58);
+diffuseColor.rgb = mix(diffuseColor.rgb, diffuseColor.rgb * lotusProfileColor, 0.62);
+diffuseColor.rgb += lotusVeinColor * lotusVeinColorField * uLotusVeinIntensity * uLotusGrowth * 7.5;
+diffuseColor.a *= mix(0.7, 1.0, uLotusGrowth);`,
+      /** Spliced after `#include <emissivemap_fragment>` — backlit subsurface scatter. */
+      fragmentEmissiveInjection: `
+float lotusBacklight = pow(1.0 - abs(dot(normalize(vLotusWorldNormal), normalize(vLotusViewDir))), 2.15);
+float lotusTranslucency = mix(uLotusTransmissionBase, uLotusTransmissionEdge, lotusEdge);
+float lotusPulse = 0.92 + sin(uLotusTime * 0.65 + vLotusVeinPhase * 6.28318) * 0.08;
+vec3 lotusScatter = uLotusSubsurfaceColor * lotusBacklight * lotusTranslucency * uLotusSSS * uLotusGrowth * lotusPulse;
+totalEmissiveRadiance += lotusScatter * (0.28 + uLotusBloom * 0.72);`
+    };
+    exports.LOTUS_PETAL_CHUNK_ENTRIES = [
+      { stage: "vertex", include: "common", code: exports.LOTUS_PETAL_SHADER_CHUNKS.vertexHeader },
+      { stage: "vertex", include: "begin_vertex", code: exports.LOTUS_PETAL_SHADER_CHUNKS.vertexBend },
+      { stage: "vertex", include: "worldpos_vertex", code: exports.LOTUS_PETAL_SHADER_CHUNKS.vertexWorld },
+      { stage: "fragment", include: "common", code: exports.LOTUS_PETAL_SHADER_CHUNKS.fragmentHeader },
+      { stage: "fragment", include: "normal_fragment_maps", code: exports.LOTUS_PETAL_SHADER_CHUNKS.fragmentNormalInjection },
+      { stage: "fragment", include: "color_fragment", code: exports.LOTUS_PETAL_SHADER_CHUNKS.fragmentColorInjection },
+      { stage: "fragment", include: "emissivemap_fragment", code: exports.LOTUS_PETAL_SHADER_CHUNKS.fragmentEmissiveInjection }
+    ];
+    LOTUS_PETAL_DEFAULT_DYNAMIC = {
+      devTime: 1,
+      curlScale: 1,
+      growth: 1,
+      bloom: 1,
+      time: 0
+    };
+    exports.LOTUS_PETAL_UNIFORM_BINDINGS = {
+      uPetalDevTime: "devTime",
+      uLotusGrowth: "growth",
+      uLotusBloom: "bloom",
+      uLotusTime: "time"
+    };
+  }
+});
+
+exports.assertBotanicalLotusConfig = assertBotanicalLotusConfig;
+exports.buildLotusPetalMaterialSpec = buildLotusPetalMaterialSpec;
+exports.buildLotusSceneFromComposition = buildLotusSceneFromComposition;
+exports.createBotanicalLotusRenderProfile = createBotanicalLotusRenderProfile;
+exports.createLotusMeristem = createLotusMeristem;
+exports.createLotusMorphogen = createLotusMorphogen;
+exports.createLotusMorphogen2D = createLotusMorphogen2D;
+exports.createLotusPetalTurgor = createLotusPetalTurgor;
+exports.createLotusPond = createLotusPond;
+exports.deriveBotanicalLotusAnchorStatus = deriveBotanicalLotusAnchorStatus;
+exports.deriveLotusBloomFromGlow = deriveLotusBloomFromGlow;
+exports.disturbLotusPond = disturbLotusPond;
+exports.generateBotanicalNormalMap = generateBotanicalNormalMap;
+exports.generateBotanicalRoughnessMap = generateBotanicalRoughnessMap;
+exports.getBotanicalLotusPetalCount = getBotanicalLotusPetalCount;
+exports.init_BotanicalLotusTrait = init_BotanicalLotusTrait;
+exports.lotusMorphogen2DPeaks = lotusMorphogen2DPeaks;
+exports.lotusMorphogen2DSampleAt = lotusMorphogen2DSampleAt;
+exports.lotusMorphogenPeaks = lotusMorphogenPeaks;
+exports.lotusPetalRenderColor = lotusPetalRenderColor;
+exports.lotusPetalTurgorOpenProgress = lotusPetalTurgorOpenProgress;
+exports.lotusPetalTurgorTipDeg = lotusPetalTurgorTipDeg;
+exports.lotusPondSurface = lotusPondSurface;
+exports.normalizeBotanicalLotusConfig = normalizeBotanicalLotusConfig;
+exports.simulateLotusMorphogenesis = simulateLotusMorphogenesis;
+exports.simulateLotusPetalGrowth = simulateLotusPetalGrowth;
+exports.simulateLotusPhyllotaxis = simulateLotusPhyllotaxis;
+exports.stepLotusMeristem = stepLotusMeristem;
+exports.stepLotusMorphogen = stepLotusMorphogen;
+exports.stepLotusMorphogen2D = stepLotusMorphogen2D;
+exports.stepLotusPetalTurgor = stepLotusPetalTurgor;
+exports.stepLotusPond = stepLotusPond;
+exports.validateBotanicalLotusConfig = validateBotanicalLotusConfig;
+//# sourceMappingURL=chunk-6Q7RC2MK.cjs.map
+//# sourceMappingURL=chunk-6Q7RC2MK.cjs.map