@holoscript/core 8.0.0 → 8.0.1

package/dist/traits/botanical-lotus.cjs

@@ -1,41 +1,177 @@
 'use strict';
 
-var chunkWDT3JTGM_cjs = require('../chunk-WDT3JTGM.cjs');
+var chunk6Q7RC2MK_cjs = require('../chunk-6Q7RC2MK.cjs');
 require('../chunk-HCCQLAA4.cjs');
 
-
+chunk6Q7RC2MK_cjs.init_BotanicalLotusTrait();
 
 Object.defineProperty(exports, "DEFAULT_BOTANICAL_LOTUS_CONFIG", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.DEFAULT_BOTANICAL_LOTUS_CONFIG; }
+  get: function () { return chunk6Q7RC2MK_cjs.DEFAULT_BOTANICAL_LOTUS_CONFIG; }
+});
+Object.defineProperty(exports, "LOTUS_GENESIS_SEED_PLACEHOLDER", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_GENESIS_SEED_PLACEHOLDER; }
+});
+Object.defineProperty(exports, "LOTUS_GOLDEN_ANGLE_DEG", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_GOLDEN_ANGLE_DEG; }
+});
+Object.defineProperty(exports, "LOTUS_GROWTH_SECONDS", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_GROWTH_SECONDS; }
+});
+Object.defineProperty(exports, "LOTUS_OUTER_PETAL_COLOR", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_OUTER_PETAL_COLOR; }
+});
+Object.defineProperty(exports, "LOTUS_PETAL_CHUNK_ENTRIES", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_PETAL_CHUNK_ENTRIES; }
+});
+Object.defineProperty(exports, "LOTUS_PETAL_SHADER_CHUNKS", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_PETAL_SHADER_CHUNKS; }
+});
+Object.defineProperty(exports, "LOTUS_PETAL_UNIFORM_BINDINGS", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_PETAL_UNIFORM_BINDINGS; }
+});
+Object.defineProperty(exports, "LOTUS_RING_SCALING", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.LOTUS_RING_SCALING; }
 });
 Object.defineProperty(exports, "assertBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.assertBotanicalLotusConfig; }
+  get: function () { return chunk6Q7RC2MK_cjs.assertBotanicalLotusConfig; }
 });
 Object.defineProperty(exports, "botanicalLotusHandler", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.botanicalLotusHandler; }
+  get: function () { return chunk6Q7RC2MK_cjs.botanicalLotusHandler; }
+});
+Object.defineProperty(exports, "buildLotusPetalMaterialSpec", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.buildLotusPetalMaterialSpec; }
+});
+Object.defineProperty(exports, "buildLotusSceneFromComposition", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.buildLotusSceneFromComposition; }
 });
 Object.defineProperty(exports, "createBotanicalLotusRenderProfile", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.createBotanicalLotusRenderProfile; }
+  get: function () { return chunk6Q7RC2MK_cjs.createBotanicalLotusRenderProfile; }
+});
+Object.defineProperty(exports, "createLotusMeristem", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.createLotusMeristem; }
+});
+Object.defineProperty(exports, "createLotusMorphogen", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.createLotusMorphogen; }
+});
+Object.defineProperty(exports, "createLotusMorphogen2D", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.createLotusMorphogen2D; }
+});
+Object.defineProperty(exports, "createLotusPetalTurgor", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.createLotusPetalTurgor; }
+});
+Object.defineProperty(exports, "createLotusPond", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.createLotusPond; }
 });
 Object.defineProperty(exports, "deriveBotanicalLotusAnchorStatus", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.deriveBotanicalLotusAnchorStatus; }
+  get: function () { return chunk6Q7RC2MK_cjs.deriveBotanicalLotusAnchorStatus; }
+});
+Object.defineProperty(exports, "deriveLotusBloomFromGlow", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.deriveLotusBloomFromGlow; }
+});
+Object.defineProperty(exports, "disturbLotusPond", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.disturbLotusPond; }
+});
+Object.defineProperty(exports, "generateBotanicalNormalMap", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.generateBotanicalNormalMap; }
+});
+Object.defineProperty(exports, "generateBotanicalRoughnessMap", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.generateBotanicalRoughnessMap; }
 });
 Object.defineProperty(exports, "getBotanicalLotusPetalCount", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.getBotanicalLotusPetalCount; }
+  get: function () { return chunk6Q7RC2MK_cjs.getBotanicalLotusPetalCount; }
+});
+Object.defineProperty(exports, "lotusMorphogen2DPeaks", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusMorphogen2DPeaks; }
+});
+Object.defineProperty(exports, "lotusMorphogen2DSampleAt", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusMorphogen2DSampleAt; }
+});
+Object.defineProperty(exports, "lotusMorphogenPeaks", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusMorphogenPeaks; }
+});
+Object.defineProperty(exports, "lotusPetalRenderColor", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusPetalRenderColor; }
+});
+Object.defineProperty(exports, "lotusPetalTurgorOpenProgress", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusPetalTurgorOpenProgress; }
+});
+Object.defineProperty(exports, "lotusPetalTurgorTipDeg", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusPetalTurgorTipDeg; }
+});
+Object.defineProperty(exports, "lotusPondSurface", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.lotusPondSurface; }
 });
 Object.defineProperty(exports, "normalizeBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.normalizeBotanicalLotusConfig; }
+  get: function () { return chunk6Q7RC2MK_cjs.normalizeBotanicalLotusConfig; }
+});
+Object.defineProperty(exports, "simulateLotusMorphogenesis", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.simulateLotusMorphogenesis; }
+});
+Object.defineProperty(exports, "simulateLotusPetalGrowth", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.simulateLotusPetalGrowth; }
+});
+Object.defineProperty(exports, "simulateLotusPhyllotaxis", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.simulateLotusPhyllotaxis; }
+});
+Object.defineProperty(exports, "stepLotusMeristem", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.stepLotusMeristem; }
+});
+Object.defineProperty(exports, "stepLotusMorphogen", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.stepLotusMorphogen; }
+});
+Object.defineProperty(exports, "stepLotusMorphogen2D", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.stepLotusMorphogen2D; }
+});
+Object.defineProperty(exports, "stepLotusPetalTurgor", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.stepLotusPetalTurgor; }
+});
+Object.defineProperty(exports, "stepLotusPond", {
+  enumerable: true,
+  get: function () { return chunk6Q7RC2MK_cjs.stepLotusPond; }
 });
 Object.defineProperty(exports, "validateBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunkWDT3JTGM_cjs.validateBotanicalLotusConfig; }
+  get: function () { return chunk6Q7RC2MK_cjs.validateBotanicalLotusConfig; }
 });
 //# sourceMappingURL=botanical-lotus.cjs.map
 //# sourceMappingURL=botanical-lotus.cjs.map

package/dist/traits/botanical-lotus.d.ts

@@ -49,6 +49,9 @@ export interface BotanicalLotusMaterial {
   vein_normal_intensity: number;
   edge_curl_intensity: number;
   gravity_sag_outer: number;
+  sheen: number;
+  sheen_roughness: number;
+  sheen_color: string;
 }
 
 export interface BotanicalLotusPetalRing {
@@ -140,6 +143,9 @@ export interface BotanicalLotusRenderProfile {
     roughness: number;
     ior: number;
     vein_normal_intensity: number;
+    sheen: number;
+    sheen_roughness: number;
+    sheen_color: string;
   };
   colors: BotanicalLotusColors;
   stamen_filament_count: number;
@@ -170,3 +176,327 @@ export declare function createBotanicalLotusRenderProfile(
   lighting?: BotanicalLotusLighting
 ): BotanicalLotusRenderProfile;
 export declare const botanicalLotusHandler: unknown;
+
+// --- Scene compiler (.holo composition -> deterministic lotus scene) ---------
+
+export type LotusBloomState = 'sealed' | 'budding' | 'blooming' | 'full' | 'wilted';
+
+export interface LotusCompositionObject {
+  name?: string;
+  properties?: ReadonlyArray<{ key: string; value: unknown }>;
+  traits?: ReadonlyArray<{ name: string; config?: Record<string, unknown> }>;
+}
+
+export interface LotusSceneRing {
+  ring: 1 | 2 | 3;
+  count: number;
+  radius: number;
+  length: number;
+  width: number;
+  cup: number;
+  gravity_sag: number;
+  height: number;
+}
+
+export interface LotusScenePetal {
+  index: number;
+  ring: 1 | 2 | 3;
+  ringIndex: number;
+  angle: number;
+  radius: number;
+  length: number;
+  width: number;
+  cup: number;
+  gravitySag: number;
+  height: number;
+  color: string;
+  bloom: LotusBloomState;
+  label: string;
+  title: string;
+}
+
+export interface LotusScene {
+  seed: string;
+  golden_angle_deg: number;
+  growth_seconds: number;
+  rings: LotusSceneRing[];
+  petals: LotusScenePetal[];
+  material: BotanicalLotusRenderProfile['pbr_uniforms'];
+  colors: BotanicalLotusColors;
+  stamen_filament_count: number;
+  seed_pod_dot_pattern: string;
+}
+
+export declare const LOTUS_GOLDEN_ANGLE_DEG: number;
+export declare const LOTUS_GROWTH_SECONDS: number;
+export declare const LOTUS_GENESIS_SEED_PLACEHOLDER: string;
+export declare const LOTUS_RING_SCALING: Record<
+  1 | 2 | 3,
+  { radius: number; length: number; width: number; height: number }
+>;
+export declare const LOTUS_OUTER_PETAL_COLOR: string;
+
+export declare function deriveLotusBloomFromGlow(intensity: number, pulse: boolean): LotusBloomState;
+export declare function lotusPetalRenderColor(
+  ring: 1 | 2 | 3,
+  isRoot: boolean,
+  colors: BotanicalLotusColors
+): string;
+export declare function buildLotusSceneFromComposition(
+  objects: ReadonlyArray<LotusCompositionObject>,
+  profile?: BotanicalLotusRenderProfile,
+  options?: { seed?: string }
+): LotusScene;
+
+export declare const LOTUS_PETAL_SHADER_CHUNKS: {
+  readonly vertexHeader: string;
+  readonly vertexBend: string;
+  readonly vertexWorld: string;
+  readonly fragmentHeader: string;
+  readonly fragmentNormalInjection: string;
+  readonly fragmentColorInjection: string;
+  readonly fragmentEmissiveInjection: string;
+};
+
+// --- Procedural texture data (three-free; renderer wraps in DataTexture) ------
+
+export interface ProceduralTextureData {
+  width: number;
+  height: number;
+  data: Uint8Array;
+}
+
+export type BotanicalSurfacePattern = 'petal_veins' | 'leaf_radial' | 'stalk_fiber' | 'micro';
+
+export declare function generateBotanicalNormalMap(opts: {
+  size?: number;
+  seed?: number;
+  pattern: BotanicalSurfacePattern;
+  strength?: number;
+}): ProceduralTextureData;
+
+export declare function generateBotanicalRoughnessMap(opts: {
+  size?: number;
+  seed?: number;
+  base?: number;
+  variance?: number;
+  scale?: number;
+}): ProceduralTextureData;
+
+// --- Morphogenesis: developmental phyllotaxis simulation (grown, not placed) ---
+
+export interface LotusPrimordium {
+  index: number;
+  r: number;
+  theta: number;
+}
+
+export interface LotusMorphogenesisParams {
+  count: number;
+  seed?: number;
+  apexRadius?: number;
+  radialVelocity?: number;
+  inhibitionExponent?: number;
+  angularSamples?: number;
+}
+
+export interface LotusMorphogenesisResult {
+  primordia: LotusPrimordium[];
+  emergentDivergenceDeg: number;
+  divergenceSpreadDeg: number;
+  resolvedParams: {
+    count: number;
+    seed: number;
+    apexRadius: number;
+    radialVelocity: number;
+    inhibitionExponent: number;
+    angularSamples: number;
+  };
+}
+
+export declare function simulateLotusMorphogenesis(
+  params: LotusMorphogenesisParams
+): LotusMorphogenesisResult;
+
+export interface LotusPhyllotaxisParams {
+  count: number;
+  seed?: number;
+  apexRadius?: number;
+  radialVelocity?: number;
+  inhibitorRange?: number;
+  threshold?: number;
+  chiralWindowDeg?: readonly [number, number];
+  angularSamples?: number;
+}
+
+export interface LotusPhyllotaxisResult {
+  primordia: LotusPrimordium[];
+  emergentDivergenceDeg: number;
+  divergenceSpreadDeg: number;
+}
+
+export declare function simulateLotusPhyllotaxis(
+  params: LotusPhyllotaxisParams
+): LotusPhyllotaxisResult;
+
+export interface LotusMeristem {
+  primordia: LotusPrimordium[];
+  last: number;
+  apexRadius: number;
+  v: number;
+  range: number;
+  threshold: number;
+  wMin: number;
+  wMax: number;
+  samples: number;
+  step: number;
+}
+
+export declare function createLotusMeristem(params: LotusPhyllotaxisParams): LotusMeristem;
+export declare function stepLotusMeristem(m: LotusMeristem): boolean;
+
+export interface LotusPetalGrowthParams {
+  developmentalTime: number;
+  budCurl?: number;
+  openCurl?: number;
+  matureStart?: number;
+  matureSpan?: number;
+  acropetalDelay?: number;
+  baseAngleDeg?: number;
+  segments?: number;
+}
+
+export interface LotusPetalGrowthState {
+  tipAngleDeg: number;
+  centerline: Array<[number, number]>;
+  curvature: number[];
+  baseMaturity: number;
+  tipMaturity: number;
+}
+
+export declare function simulateLotusPetalGrowth(
+  params: LotusPetalGrowthParams
+): LotusPetalGrowthState;
+
+export interface LotusPondParams {
+  size?: number;
+  extent?: number;
+  waveSpeed?: number;
+  damping?: number;
+  stalkRadius?: number;
+  capillaryLength?: number;
+  contactRise?: number;
+}
+
+export interface LotusPondState {
+  size: number;
+  extent: number;
+  c: number;
+  damping: number;
+  dx: number;
+  h: Float32Array;
+  v: Float32Array;
+  meniscus: Float32Array;
+  mask: Float32Array;
+}
+
+export declare function createLotusPond(params?: LotusPondParams): LotusPondState;
+export declare function disturbLotusPond(
+  state: LotusPondState,
+  worldX: number,
+  worldZ: number,
+  amplitude: number,
+  radius?: number
+): void;
+export declare function stepLotusPond(state: LotusPondState, dt: number): void;
+export declare function lotusPondSurface(state: LotusPondState, out?: Float32Array): Float32Array;
+
+export interface LotusMorphogenParams {
+  size?: number;
+  diffusionRatio?: number;
+  gamma?: number;
+  a?: number;
+  b?: number;
+  seed?: number;
+}
+
+export interface LotusMorphogenField {
+  size: number;
+  d: number;
+  gamma: number;
+  a: number;
+  b: number;
+  dt: number;
+  u: Float32Array;
+  v: Float32Array;
+}
+
+export declare function createLotusMorphogen(params?: LotusMorphogenParams): LotusMorphogenField;
+export declare function stepLotusMorphogen(field: LotusMorphogenField, iterations?: number): void;
+export declare function lotusMorphogenPeaks(field: LotusMorphogenField): number;
+
+export interface LotusMorphogen2DParams {
+  size?: number;
+  diffusionRatio?: number;
+  gamma?: number;
+  a?: number;
+  b?: number;
+  seed?: number;
+}
+export interface LotusMorphogen2DField {
+  size: number;
+  d: number;
+  gamma: number;
+  a: number;
+  b: number;
+  dt: number;
+  u: Float32Array;
+  v: Float32Array;
+  mask: Uint8Array;
+}
+export interface LotusMorphogen2DPeak {
+  x: number;
+  y: number;
+  radius: number;
+  angle: number;
+  value: number;
+}
+export declare function createLotusMorphogen2D(params?: LotusMorphogen2DParams): LotusMorphogen2DField;
+export declare function stepLotusMorphogen2D(field: LotusMorphogen2DField, iterations?: number): void;
+export declare function lotusMorphogen2DPeaks(field: LotusMorphogen2DField): LotusMorphogen2DPeak[];
+export declare function lotusMorphogen2DSampleAt(field: LotusMorphogen2DField, x: number, y: number): number;
+
+export interface LotusPetalTurgorParams {
+  budCurl?: number;
+  openCurl?: number;
+  matureStart?: number;
+  matureSpan?: number;
+  acropetalDelay?: number;
+  baseAngleDeg?: number;
+  segments?: number;
+  turgorStiffness?: number;
+  turgorRise?: number;
+}
+
+export interface LotusPetalTurgorState {
+  segments: number;
+  baseAngle: number;
+  budCurl: number;
+  openCurl: number;
+  matureStart: number;
+  matureSpan: number;
+  acropetalDelay: number;
+  turgorStiffness: number;
+  turgorRise: number;
+  turgor: number;
+  kappaActual: Float32Array;
+}
+
+export declare function createLotusPetalTurgor(params?: LotusPetalTurgorParams): LotusPetalTurgorState;
+export declare function stepLotusPetalTurgor(
+  state: LotusPetalTurgorState,
+  dt: number,
+  developmentalTime: number
+): void;
+export declare function lotusPetalTurgorTipDeg(state: LotusPetalTurgorState): number;
+export declare function lotusPetalTurgorOpenProgress(state: LotusPetalTurgorState): number;

package/dist/traits/botanical-lotus.js

@@ -1,4 +1,7 @@
-export { DEFAULT_BOTANICAL_LOTUS_CONFIG, assertBotanicalLotusConfig, botanicalLotusHandler, createBotanicalLotusRenderProfile, deriveBotanicalLotusAnchorStatus, getBotanicalLotusPetalCount, normalizeBotanicalLotusConfig, validateBotanicalLotusConfig } from '../chunk-VECQYRXL.js';
+import { init_BotanicalLotusTrait } from '../chunk-4GU5GCIY.js';
+export { DEFAULT_BOTANICAL_LOTUS_CONFIG, LOTUS_GENESIS_SEED_PLACEHOLDER, LOTUS_GOLDEN_ANGLE_DEG, LOTUS_GROWTH_SECONDS, LOTUS_OUTER_PETAL_COLOR, LOTUS_PETAL_CHUNK_ENTRIES, LOTUS_PETAL_SHADER_CHUNKS, LOTUS_PETAL_UNIFORM_BINDINGS, LOTUS_RING_SCALING, assertBotanicalLotusConfig, botanicalLotusHandler, buildLotusPetalMaterialSpec, buildLotusSceneFromComposition, createBotanicalLotusRenderProfile, createLotusMeristem, createLotusMorphogen, createLotusMorphogen2D, createLotusPetalTurgor, createLotusPond, deriveBotanicalLotusAnchorStatus, deriveLotusBloomFromGlow, disturbLotusPond, generateBotanicalNormalMap, generateBotanicalRoughnessMap, getBotanicalLotusPetalCount, lotusMorphogen2DPeaks, lotusMorphogen2DSampleAt, lotusMorphogenPeaks, lotusPetalRenderColor, lotusPetalTurgorOpenProgress, lotusPetalTurgorTipDeg, lotusPondSurface, normalizeBotanicalLotusConfig, simulateLotusMorphogenesis, simulateLotusPetalGrowth, simulateLotusPhyllotaxis, stepLotusMeristem, stepLotusMorphogen, stepLotusMorphogen2D, stepLotusPetalTurgor, stepLotusPond, validateBotanicalLotusConfig } from '../chunk-4GU5GCIY.js';
 import '../chunk-OL46QLBJ.js';
+
+init_BotanicalLotusTrait();
 //# sourceMappingURL=botanical-lotus.js.map
 //# sourceMappingURL=botanical-lotus.js.map