@holoscript/core 8.0.8 → 8.0.9

package/dist/traits/TraitTypes.d.ts

@@ -0,0 +1,270 @@
+import type { VRTraitName, VRHand, ThrowVelocity, CollisionEvent, Vector3, HSPlusNode } from '../types/HoloScriptPlus';
+export type { VRTraitName, VRHand, ThrowVelocity, CollisionEvent, Vector3, HSPlusNode };
+export interface TraitHandler<TConfig = unknown> {
+    name: VRTraitName;
+    defaultConfig?: TConfig;
+    onAttach?: (node: HSPlusNode, config: TConfig, context: TraitContext) => void | Promise<void>;
+    onDetach?: (node: HSPlusNode, config: TConfig, context: TraitContext) => void;
+    onUpdate?: (node: HSPlusNode, config: TConfig, context: TraitContext, delta: number) => void;
+    onEvent?: (node: HSPlusNode, config: TConfig, context: TraitContext, event: TraitEvent) => void;
+    /** Compiler adapters, validators, and metadata — typed as unknown for extensibility */
+    [key: string]: unknown;
+}
+export interface HostExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface HostExecResult {
+    code: number | null;
+    signal?: string | null;
+    stdout?: string;
+    stderr?: string;
+}
+export interface HostNetworkRequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+    credentials?: 'omit' | 'same-origin' | 'include';
+}
+export interface HostNetworkResponse {
+    status: number;
+    ok: boolean;
+    headers?: Record<string, string>;
+    body?: unknown;
+    text?: string;
+    json?: unknown;
+}
+export interface HostFileSystemCapabilities {
+    readFile: (path: string) => Promise<string> | string;
+    writeFile: (path: string, content: string) => Promise<void> | void;
+    deleteFile: (path: string) => Promise<void> | void;
+    exists?: (path: string) => Promise<boolean> | boolean;
+}
+export interface HostProcessCapabilities {
+    exec: (command: string, args?: string[], options?: HostExecOptions) => Promise<HostExecResult> | HostExecResult;
+    kill?: (pid: number, signal?: string) => Promise<void> | void;
+}
+export interface HostNetworkCapabilities {
+    fetch: (url: string, options?: HostNetworkRequestOptions) => Promise<HostNetworkResponse> | HostNetworkResponse;
+}
+/** Decoded media frame returned by HostMediaCapabilities.decodeFrames(). */
+export interface HostMediaFrame {
+    /** RGBA pixel buffer, row-major, 4 bytes per pixel. */
+    data: Uint8Array;
+    width: number;
+    height: number;
+    /** Frame display duration in milliseconds. */
+    delayMs: number;
+}
+/** GIF / video frame decoding capability. */
+export interface HostMediaCapabilities {
+    decodeFrames: (source: string | ArrayBuffer, options?: {
+        maxFrames?: number;
+        type?: 'gif' | 'video';
+    }) => Promise<HostMediaFrame[]>;
+}
+/** Depth map result from ML inference. */
+export interface HostDepthMap {
+    /** Normalised depth values in [0, 1], row-major, one value per pixel. */
+    data: Float32Array;
+    width: number;
+    height: number;
+    /** Inference backend actually used. */
+    backend: 'webgpu' | 'wasm' | 'cpu';
+    inferenceMs: number;
+}
+/** ML depth estimation capability. */
+export interface HostDepthInferenceCapabilities {
+    estimateDepth: (source: string | ArrayBuffer, options?: {
+        width?: number;
+        height?: number;
+        modelId?: string;
+    }) => Promise<HostDepthMap>;
+    readonly webgpuAvailable: boolean;
+}
+/** WebGPU compute kernel result. */
+export interface HostGpuComputeResult {
+    outputs: Record<string, ArrayBuffer>;
+    dispatchMs: number;
+}
+/** WebGPU compute dispatch capability. */
+export interface HostGpuComputeCapabilities {
+    dispatch: (shader: string, inputs: Record<string, ArrayBuffer>, workgroups: [number, number?, number?]) => Promise<HostGpuComputeResult>;
+    readonly available: boolean;
+}
+export type HostDeviceProbeScope = 'inventory' | 'presence' | 'frame-capture' | 'input' | 'actuation';
+export interface HostDeviceProbeRequest {
+    scope: HostDeviceProbeScope;
+    targetId?: string;
+    targetKind?: string;
+    timeoutMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface HostDeviceProbeResult {
+    ok: boolean;
+    status: 'present' | 'missing' | 'unsupported' | 'denied';
+    deviceId?: string;
+    targetKind?: string;
+    detail?: string;
+    metrics?: Record<string, unknown>;
+    receipt?: unknown;
+}
+/** Local target-device probe capability, e.g. headset/phone/controller presence or frame receipts. */
+export interface HostDeviceProbeCapabilities {
+    probe: (request: HostDeviceProbeRequest) => Promise<HostDeviceProbeResult>;
+    readonly available: boolean;
+}
+export interface HostCapabilities {
+    fileSystem?: HostFileSystemCapabilities;
+    process?: HostProcessCapabilities;
+    network?: HostNetworkCapabilities;
+    /** Media decoding capability — GIF/video frame extraction. */
+    media?: HostMediaCapabilities;
+    /** ML depth inference capability. */
+    depthInference?: HostDepthInferenceCapabilities;
+    /** GPU compute capability. */
+    gpuCompute?: HostGpuComputeCapabilities;
+    /** Target-device probing capability gated by StdlibPolicy device scopes. */
+    deviceProbe?: HostDeviceProbeCapabilities;
+}
+export type ARTrackingState = 'not_available' | 'limited' | 'normal' | 'lost';
+export interface ARSessionPose {
+    anchorId?: string;
+    target?: string;
+    position: Vector3;
+    rotation?: Vector3;
+    confidence?: number;
+    timestampMs?: number;
+    trackingState?: ARTrackingState;
+    source?: string;
+}
+export interface ARSessionContext {
+    readonly available: boolean;
+    getPose: (nodeId?: string) => ARSessionPose | null;
+    getAnchor?: (anchorId: string) => ARSessionPose | null;
+}
+export interface TraitContext {
+    vr: VRContext;
+    physics: PhysicsContext;
+    audio: AudioContext;
+    haptics: HapticsContext;
+    accessibility?: AccessibilityContext;
+    /** External AR/WebXR session pose provider. Traits consume poses; they do not compute anchors. */
+    arSession?: ARSessionContext;
+    camera?: {
+        position: Vector3;
+        rotation?: Vector3;
+        fov?: number;
+    };
+    player?: {
+        position: Vector3;
+        rotation?: Vector3;
+    };
+    emit: (event: string, payload?: unknown) => void;
+    getState: () => Record<string, unknown>;
+    setState: (updates: Record<string, unknown>) => void;
+    getScaleMultiplier: () => number;
+    setScaleContext: (magnitude: string) => void;
+    /** Optional action dispatcher for BehaviorTreeTrait — maps action names to external handlers.
+     *  The blackboard parameter is the BT's shared state, allowing handlers to update conditions. */
+    executeAction?: (owner: HSPlusNode, actionName: string, params: Record<string, unknown>, blackboard?: Record<string, unknown>) => boolean | 'running';
+    /** Optional host capability adapter to execute sensitive operations through policy-aware providers. */
+    hostCapabilities?: HostCapabilities;
+}
+export interface AccessibilityContext {
+    announce: (text: string) => void;
+    setScreenReaderFocus: (nodeId: string) => void;
+    setAltText: (nodeId: string, text: string) => void;
+    setHighContrast: (enabled: boolean) => void;
+}
+export interface VRContext {
+    hands: {
+        left: VRHand | null;
+        right: VRHand | null;
+    };
+    headset: {
+        position: Vector3;
+        rotation: Vector3;
+    };
+    getPointerRay: (hand: 'left' | 'right') => {
+        origin: Vector3;
+        direction: Vector3;
+    } | null;
+    getDominantHand: () => VRHand | null;
+}
+export interface PhysicsContext {
+    applyVelocity: (node: HSPlusNode, velocity: Vector3) => void;
+    applyAngularVelocity: (node: HSPlusNode, angularVelocity: Vector3) => void;
+    setKinematic: (node: HSPlusNode, kinematic: boolean) => void;
+    raycast: (origin: Vector3, direction: Vector3, maxDistance: number) => RaycastHit | null;
+    getBodyPosition: (nodeId: string) => Vector3 | null;
+    getBodyVelocity: (nodeId: string) => Vector3 | null;
+}
+export interface AudioContext {
+    playSound: (source: string, options?: {
+        position?: Vector3;
+        volume?: number;
+        spatial?: boolean;
+    }) => void;
+    updateSpatialSource?: (nodeId: string, options: {
+        hrtfProfile?: string;
+        occlusion?: number;
+        reverbWet?: number;
+    }) => void;
+    registerAmbisonicSource?: (nodeId: string, order: number) => void;
+    setAudioPortal?: (portalId: string, targetZone: string, openingSize: number) => void;
+    updateAudioMaterial?: (nodeId: string, absorption: number, reflection: number) => void;
+}
+export interface HapticsContext {
+    pulse: (hand: 'left' | 'right', intensity: number, duration?: number) => void;
+    rumble: (hand: 'left' | 'right', intensity: number) => void;
+}
+export interface RaycastHit {
+    node: HSPlusNode;
+    point: Vector3;
+    normal: Vector3;
+    distance: number;
+}
+export interface TraitEvent {
+    /** Event type identifier (e.g., 'grab_start', 'collision', 'trait_attached') */
+    type: string;
+    /** Source node that emitted the event */
+    node?: HSPlusNode;
+    /** Trait configuration at time of event */
+    config?: unknown;
+    /** Event-specific payload data */
+    payload?: Record<string, unknown>;
+    /** Arbitrary additional fields */
+    [key: string]: unknown;
+}
+export type TraitEventPayload<T = unknown> = Record<string, unknown> & T;
+/**
+ * Extract a loosely-typed payload from a TraitEvent.
+ * Returns `event.payload` if present, otherwise the event itself.
+ * The result is typed as `Record<string, any>` to allow property access
+ * without explicit casts at every call site (pragmatic trade-off).
+ */
+export declare function extractPayload(event: TraitEvent): Record<string, any>;
+/**
+ * Common interface for trait instance delegates stored on `node.__*_instance`.
+ * All methods are optional — callers must guard with `typeof instance.X === 'function'`.
+ */
+export interface TraitInstanceDelegate {
+    onDetach?: (node: HSPlusNode, ctx: TraitContext) => void;
+    onEvent?: (event: TraitEvent) => void;
+    onUpdate?: (node: HSPlusNode, ctx: TraitContext, dt: number) => void;
+    /**
+     * Per-frame stepper for solver-style delegates (e.g. GranularMaterialSystem)
+     * that integrate by time-step rather than the node/ctx-shaped `onUpdate`. A
+     * handler's onUpdate falls back to `step(dt)` when the delegate exposes no
+     * `onUpdate` — without it the solver is constructed but never advanced (the
+     * dead-delegation overclaim; see research/2026-06-24_trait-map-substrate-audit.md §3.1).
+     */
+    step?: (dt: number) => void;
+    emit?: (event: TraitEvent) => void;
+    dispose?: () => void;
+    cleanup?: () => void;
+    [key: string]: unknown;
+}

package/dist/traits/TransactionTrait.d.ts

@@ -0,0 +1,121 @@
+/**
+ * TransactionTrait — x402-native economic action handler (H2 'transaction' family).
+ *
+ * Provides a ledger of economic actions (pay, transfer, stake, unstake) for a
+ * node, with balance tracking, spend-limit enforcement, and receipt generation.
+ * All arithmetic uses integer micro-units (avoid float drift on money).
+ *
+ * ## Design principles
+ *
+ *  - Pure value semantics: every operation returns a `TxReceipt` and does NOT
+ *    call any network/chain API. The trait records intent and local ledger state;
+ *    a plugin that wraps this in a real x402 call is free to do so.
+ *  - Idempotency key: each action carries an optional `idempotencyKey`. Duplicate
+ *    keys on the same node are rejected (returns `{ ok: false, reason: 'duplicate' }`).
+ *  - Spend limits: per-action type caps (`payLimit`, `transferLimit`, `stakeLimit`)
+ *    expressed in micro-units. Operations exceeding the limit are rejected without
+ *    touching the ledger.
+ *  - Stake escrow: staked amounts are held in a separate escrow balance, not
+ *    deducted from the spendable balance. Unstake returns them to spendable.
+ *
+ * ## Micro-unit convention
+ *
+ * All amounts are integers in micro-units (e.g. 1 USD = 1_000_000 μUSD). The
+ * `unit` field on the config is informational only; arithmetic never converts.
+ *
+ * ## Domain-neutrality
+ *
+ * No domain nouns appear here. The trait applies to x402 agent wallets,
+ * HoloProtocol creator earnings, HoloMesh marketplace transactions, and any
+ * closed-loop simulated economy.
+ *
+ * ## Trait usage
+ *
+ *   onAttach: initialises ledger from config.initialBalance.
+ *   onEvent 'transaction.pay':      debit from balance → receipt.
+ *   onEvent 'transaction.transfer': debit from balance → receipt.
+ *   onEvent 'transaction.stake':    move from balance → escrow → receipt.
+ *   onEvent 'transaction.unstake':  move from escrow → balance → receipt.
+ *   onEvent 'transaction.deposit':  credit to balance → receipt.
+ *   onEvent 'transaction.ledger':   write full ledger to node.__tx_ledger.
+ */
+import type { TraitHandler } from './TraitTypes';
+/** Outcome of a single transaction action. */
+export interface TxReceipt {
+    /** Whether the action succeeded. */
+    ok: boolean;
+    /** Action type. */
+    action: 'pay' | 'transfer' | 'stake' | 'unstake' | 'deposit';
+    /** Amount in micro-units (always non-negative). */
+    amount: number;
+    /** Caller-supplied idempotency key, if any. */
+    idempotencyKey?: string;
+    /** Reason for rejection if ok=false. */
+    reason?: 'insufficient_funds' | 'limit_exceeded' | 'negative_amount' | 'duplicate' | 'insufficient_escrow';
+    /** Balance after the action (if ok=true). */
+    balanceAfter?: number;
+    /** Escrow balance after the action (if ok=true). */
+    escrowAfter?: number;
+}
+/** A ledger entry — one committed receipt. */
+export interface LedgerEntry extends TxReceipt {
+    /** Sequential entry index (0-based). */
+    index: number;
+}
+/** Spend limits by action type (micro-units). Zero = no limit. */
+export interface SpendLimits {
+    /** Max single pay amount. 0 = unlimited. Default: 0. */
+    payLimit?: number;
+    /** Max single transfer amount. 0 = unlimited. Default: 0. */
+    transferLimit?: number;
+    /** Max single stake amount. 0 = unlimited. Default: 0. */
+    stakeLimit?: number;
+}
+/** Trait configuration. */
+export interface TransactionConfig {
+    /** Starting spendable balance in micro-units. Default: 0. */
+    initialBalance?: number;
+    /** Starting escrow balance in micro-units (rare; usually 0). Default: 0. */
+    initialEscrow?: number;
+    /** Currency/unit label (informational). Default: 'μUSD'. */
+    unit?: string;
+    /** Per-action spend limits. */
+    limits?: SpendLimits;
+}
+interface TxEventBase {
+    /** Amount in micro-units. Must be a non-negative integer. */
+    amount: number;
+    /** Optional idempotency key; duplicate key on same node → rejected. */
+    idempotencyKey?: string;
+}
+export interface PayRequest extends TxEventBase {
+    type: 'transaction.pay';
+}
+export interface TransferRequest extends TxEventBase {
+    type: 'transaction.transfer';
+}
+export interface StakeRequest extends TxEventBase {
+    type: 'transaction.stake';
+}
+export interface UnstakeRequest extends TxEventBase {
+    type: 'transaction.unstake';
+}
+export interface DepositRequest extends TxEventBase {
+    type: 'transaction.deposit';
+}
+export interface TxNodeState {
+    balance: number;
+    escrow: number;
+    ledger: LedgerEntry[];
+    seenKeys: Set<string>;
+}
+/** Debit `amount` from balance (pay or transfer). */
+export declare function debitBalance(state: TxNodeState, action: 'pay' | 'transfer', amount: number, limit: number, idempotencyKey?: string): TxReceipt;
+/** Move `amount` from balance → escrow. */
+export declare function stakeBalance(state: TxNodeState, amount: number, limit: number, idempotencyKey?: string): TxReceipt;
+/** Move `amount` from escrow → balance. */
+export declare function unstakeBalance(state: TxNodeState, amount: number, idempotencyKey?: string): TxReceipt;
+/** Credit `amount` to balance. */
+export declare function depositBalance(state: TxNodeState, amount: number, idempotencyKey?: string): TxReceipt;
+export declare const transactionHandler: TraitHandler<TransactionConfig>;
+export {};

package/dist/traits/botanical-lotus.cjs

@@ -1,197 +1,201 @@
 'use strict';
 
-var chunk56VOWURB_cjs = require('../chunk-56VOWURB.cjs');
-require('../chunk-HCCQLAA4.cjs');
+var chunkENZCIQZC_cjs = require('../chunk-ENZCIQZC.cjs');
+require('../chunk-ZHPMP447.cjs');
+
 
-chunk56VOWURB_cjs.init_BotanicalLotusTrait();
 
 Object.defineProperty(exports, "DEFAULT_BOTANICAL_LOTUS_CONFIG", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.DEFAULT_BOTANICAL_LOTUS_CONFIG; }
+  get: function () { return chunkENZCIQZC_cjs.DEFAULT_BOTANICAL_LOTUS_CONFIG; }
 });
 Object.defineProperty(exports, "DEFAULT_LOTUS_PETAL_GEOMETRY_PARAMS", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.DEFAULT_LOTUS_PETAL_GEOMETRY_PARAMS; }
+  get: function () { return chunkENZCIQZC_cjs.DEFAULT_LOTUS_PETAL_GEOMETRY_PARAMS; }
 });
 Object.defineProperty(exports, "LOTUS_GENESIS_SEED_PLACEHOLDER", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_GENESIS_SEED_PLACEHOLDER; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_GENESIS_SEED_PLACEHOLDER; }
 });
 Object.defineProperty(exports, "LOTUS_GOLDEN_ANGLE_DEG", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_GOLDEN_ANGLE_DEG; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_GOLDEN_ANGLE_DEG; }
 });
 Object.defineProperty(exports, "LOTUS_GROWTH_SECONDS", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_GROWTH_SECONDS; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_GROWTH_SECONDS; }
 });
 Object.defineProperty(exports, "LOTUS_OUTER_PETAL_COLOR", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_OUTER_PETAL_COLOR; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_OUTER_PETAL_COLOR; }
 });
 Object.defineProperty(exports, "LOTUS_PETAL_CHUNK_ENTRIES", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_PETAL_CHUNK_ENTRIES; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_PETAL_CHUNK_ENTRIES; }
 });
 Object.defineProperty(exports, "LOTUS_PETAL_SHADER_CHUNKS", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_PETAL_SHADER_CHUNKS; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_PETAL_SHADER_CHUNKS; }
 });
 Object.defineProperty(exports, "LOTUS_PETAL_UNIFORM_BINDINGS", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_PETAL_UNIFORM_BINDINGS; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_PETAL_UNIFORM_BINDINGS; }
 });
 Object.defineProperty(exports, "LOTUS_RING_SCALING", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.LOTUS_RING_SCALING; }
+  get: function () { return chunkENZCIQZC_cjs.LOTUS_RING_SCALING; }
 });
 Object.defineProperty(exports, "assertBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.assertBotanicalLotusConfig; }
+  get: function () { return chunkENZCIQZC_cjs.assertBotanicalLotusConfig; }
 });
 Object.defineProperty(exports, "botanicalLotusHandler", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.botanicalLotusHandler; }
+  get: function () { return chunkENZCIQZC_cjs.botanicalLotusHandler; }
 });
 Object.defineProperty(exports, "buildLotusFlowerPlacements", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.buildLotusFlowerPlacements; }
+  get: function () { return chunkENZCIQZC_cjs.buildLotusFlowerPlacements; }
 });
 Object.defineProperty(exports, "buildLotusPetalGeometryData", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.buildLotusPetalGeometryData; }
+  get: function () { return chunkENZCIQZC_cjs.buildLotusPetalGeometryData; }
 });
 Object.defineProperty(exports, "buildLotusPetalMaterialSpec", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.buildLotusPetalMaterialSpec; }
+  get: function () { return chunkENZCIQZC_cjs.buildLotusPetalMaterialSpec; }
+});
+Object.defineProperty(exports, "buildLotusPhyllotaxisPetalLayout", {
+  enumerable: true,
+  get: function () { return chunkENZCIQZC_cjs.buildLotusPhyllotaxisPetalLayout; }
 });
 Object.defineProperty(exports, "buildLotusSceneFromComposition", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.buildLotusSceneFromComposition; }
+  get: function () { return chunkENZCIQZC_cjs.buildLotusSceneFromComposition; }
 });
 Object.defineProperty(exports, "buildLotusSceneScaffold", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.buildLotusSceneScaffold; }
+  get: function () { return chunkENZCIQZC_cjs.buildLotusSceneScaffold; }
 });
 Object.defineProperty(exports, "createBotanicalLotusRenderProfile", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createBotanicalLotusRenderProfile; }
+  get: function () { return chunkENZCIQZC_cjs.createBotanicalLotusRenderProfile; }
 });
 Object.defineProperty(exports, "createLotusMeristem", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createLotusMeristem; }
+  get: function () { return chunkENZCIQZC_cjs.createLotusMeristem; }
 });
 Object.defineProperty(exports, "createLotusMorphogen", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createLotusMorphogen; }
+  get: function () { return chunkENZCIQZC_cjs.createLotusMorphogen; }
 });
 Object.defineProperty(exports, "createLotusMorphogen2D", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createLotusMorphogen2D; }
+  get: function () { return chunkENZCIQZC_cjs.createLotusMorphogen2D; }
 });
 Object.defineProperty(exports, "createLotusPetalTurgor", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createLotusPetalTurgor; }
+  get: function () { return chunkENZCIQZC_cjs.createLotusPetalTurgor; }
 });
 Object.defineProperty(exports, "createLotusPond", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.createLotusPond; }
+  get: function () { return chunkENZCIQZC_cjs.createLotusPond; }
 });
 Object.defineProperty(exports, "deriveBotanicalLotusAnchorStatus", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.deriveBotanicalLotusAnchorStatus; }
+  get: function () { return chunkENZCIQZC_cjs.deriveBotanicalLotusAnchorStatus; }
 });
 Object.defineProperty(exports, "deriveLotusBloomFromGlow", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.deriveLotusBloomFromGlow; }
+  get: function () { return chunkENZCIQZC_cjs.deriveLotusBloomFromGlow; }
 });
 Object.defineProperty(exports, "disturbLotusPond", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.disturbLotusPond; }
+  get: function () { return chunkENZCIQZC_cjs.disturbLotusPond; }
 });
 Object.defineProperty(exports, "generateBotanicalNormalMap", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.generateBotanicalNormalMap; }
+  get: function () { return chunkENZCIQZC_cjs.generateBotanicalNormalMap; }
 });
 Object.defineProperty(exports, "generateBotanicalRoughnessMap", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.generateBotanicalRoughnessMap; }
+  get: function () { return chunkENZCIQZC_cjs.generateBotanicalRoughnessMap; }
 });
 Object.defineProperty(exports, "getBotanicalLotusPetalCount", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.getBotanicalLotusPetalCount; }
+  get: function () { return chunkENZCIQZC_cjs.getBotanicalLotusPetalCount; }
 });
 Object.defineProperty(exports, "lotusMorphogen2DPeaks", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusMorphogen2DPeaks; }
+  get: function () { return chunkENZCIQZC_cjs.lotusMorphogen2DPeaks; }
 });
 Object.defineProperty(exports, "lotusMorphogen2DSampleAt", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusMorphogen2DSampleAt; }
+  get: function () { return chunkENZCIQZC_cjs.lotusMorphogen2DSampleAt; }
 });
 Object.defineProperty(exports, "lotusMorphogenPeaks", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusMorphogenPeaks; }
+  get: function () { return chunkENZCIQZC_cjs.lotusMorphogenPeaks; }
 });
 Object.defineProperty(exports, "lotusPetalGeometryParamsFromProfile", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusPetalGeometryParamsFromProfile; }
+  get: function () { return chunkENZCIQZC_cjs.lotusPetalGeometryParamsFromProfile; }
 });
 Object.defineProperty(exports, "lotusPetalRenderColor", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusPetalRenderColor; }
+  get: function () { return chunkENZCIQZC_cjs.lotusPetalRenderColor; }
 });
 Object.defineProperty(exports, "lotusPetalTurgorOpenProgress", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusPetalTurgorOpenProgress; }
+  get: function () { return chunkENZCIQZC_cjs.lotusPetalTurgorOpenProgress; }
 });
 Object.defineProperty(exports, "lotusPetalTurgorTipDeg", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusPetalTurgorTipDeg; }
+  get: function () { return chunkENZCIQZC_cjs.lotusPetalTurgorTipDeg; }
 });
 Object.defineProperty(exports, "lotusPondSurface", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.lotusPondSurface; }
+  get: function () { return chunkENZCIQZC_cjs.lotusPondSurface; }
 });
 Object.defineProperty(exports, "normalizeBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.normalizeBotanicalLotusConfig; }
+  get: function () { return chunkENZCIQZC_cjs.normalizeBotanicalLotusConfig; }
 });
 Object.defineProperty(exports, "simulateLotusMorphogenesis", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.simulateLotusMorphogenesis; }
+  get: function () { return chunkENZCIQZC_cjs.simulateLotusMorphogenesis; }
 });
 Object.defineProperty(exports, "simulateLotusPetalGrowth", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.simulateLotusPetalGrowth; }
+  get: function () { return chunkENZCIQZC_cjs.simulateLotusPetalGrowth; }
 });
 Object.defineProperty(exports, "simulateLotusPhyllotaxis", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.simulateLotusPhyllotaxis; }
+  get: function () { return chunkENZCIQZC_cjs.simulateLotusPhyllotaxis; }
 });
 Object.defineProperty(exports, "stepLotusMeristem", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.stepLotusMeristem; }
+  get: function () { return chunkENZCIQZC_cjs.stepLotusMeristem; }
 });
 Object.defineProperty(exports, "stepLotusMorphogen", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.stepLotusMorphogen; }
+  get: function () { return chunkENZCIQZC_cjs.stepLotusMorphogen; }
 });
 Object.defineProperty(exports, "stepLotusMorphogen2D", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.stepLotusMorphogen2D; }
+  get: function () { return chunkENZCIQZC_cjs.stepLotusMorphogen2D; }
 });
 Object.defineProperty(exports, "stepLotusPetalTurgor", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.stepLotusPetalTurgor; }
+  get: function () { return chunkENZCIQZC_cjs.stepLotusPetalTurgor; }
 });
 Object.defineProperty(exports, "stepLotusPond", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.stepLotusPond; }
+  get: function () { return chunkENZCIQZC_cjs.stepLotusPond; }
 });
 Object.defineProperty(exports, "validateBotanicalLotusConfig", {
   enumerable: true,
-  get: function () { return chunk56VOWURB_cjs.validateBotanicalLotusConfig; }
+  get: function () { return chunkENZCIQZC_cjs.validateBotanicalLotusConfig; }
 });
 //# sourceMappingURL=botanical-lotus.cjs.map
 //# sourceMappingURL=botanical-lotus.cjs.map

package/dist/traits/botanical-lotus.js

@@ -1,7 +1,4 @@
-import { init_BotanicalLotusTrait } from '../chunk-B4EKV6HQ.js';
-export { DEFAULT_BOTANICAL_LOTUS_CONFIG, DEFAULT_LOTUS_PETAL_GEOMETRY_PARAMS, 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, buildLotusFlowerPlacements, buildLotusPetalGeometryData, buildLotusPetalMaterialSpec, buildLotusSceneFromComposition, buildLotusSceneScaffold, createBotanicalLotusRenderProfile, createLotusMeristem, createLotusMorphogen, createLotusMorphogen2D, createLotusPetalTurgor, createLotusPond, deriveBotanicalLotusAnchorStatus, deriveLotusBloomFromGlow, disturbLotusPond, generateBotanicalNormalMap, generateBotanicalRoughnessMap, getBotanicalLotusPetalCount, lotusMorphogen2DPeaks, lotusMorphogen2DSampleAt, lotusMorphogenPeaks, lotusPetalGeometryParamsFromProfile, lotusPetalRenderColor, lotusPetalTurgorOpenProgress, lotusPetalTurgorTipDeg, lotusPondSurface, normalizeBotanicalLotusConfig, simulateLotusMorphogenesis, simulateLotusPetalGrowth, simulateLotusPhyllotaxis, stepLotusMeristem, stepLotusMorphogen, stepLotusMorphogen2D, stepLotusPetalTurgor, stepLotusPond, validateBotanicalLotusConfig } from '../chunk-B4EKV6HQ.js';
-import '../chunk-OL46QLBJ.js';
-
-init_BotanicalLotusTrait();
+export { DEFAULT_BOTANICAL_LOTUS_CONFIG, DEFAULT_LOTUS_PETAL_GEOMETRY_PARAMS, 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, buildLotusFlowerPlacements, buildLotusPetalGeometryData, buildLotusPetalMaterialSpec, buildLotusPhyllotaxisPetalLayout, buildLotusSceneFromComposition, buildLotusSceneScaffold, createBotanicalLotusRenderProfile, createLotusMeristem, createLotusMorphogen, createLotusMorphogen2D, createLotusPetalTurgor, createLotusPond, deriveBotanicalLotusAnchorStatus, deriveLotusBloomFromGlow, disturbLotusPond, generateBotanicalNormalMap, generateBotanicalRoughnessMap, getBotanicalLotusPetalCount, lotusMorphogen2DPeaks, lotusMorphogen2DSampleAt, lotusMorphogenPeaks, lotusPetalGeometryParamsFromProfile, lotusPetalRenderColor, lotusPetalTurgorOpenProgress, lotusPetalTurgorTipDeg, lotusPondSurface, normalizeBotanicalLotusConfig, simulateLotusMorphogenesis, simulateLotusPetalGrowth, simulateLotusPhyllotaxis, stepLotusMeristem, stepLotusMorphogen, stepLotusMorphogen2D, stepLotusPetalTurgor, stepLotusPond, validateBotanicalLotusConfig } from '../chunk-VKCTYLDN.js';
+import '../chunk-W4GABFCR.js';
 //# sourceMappingURL=botanical-lotus.js.map
 //# sourceMappingURL=botanical-lotus.js.map