@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/CrystallineOrganism/OrganismParticles.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * OrganismParticles - Emotion-Driven Particle System
+ *
+ * Particle aura around the organism, driven by VisualState from the AVO emotion system.
+ * Similar to GlyphObject's particle system but for crystalline organisms.
+ */
+import { useRef, useMemo } from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+const MIN_RADIUS = 1.1;
+const MAX_RADIUS = 1.6;
+const OUTER_BOUND = 2.2;
+const INNER_BOUND = 0.7;
+export function OrganismParticles({ visualState, shellRadius }) {
+    const pointsRef = useRef(null);
+    const particlesRef = useRef([]);
+    const maxParticles = 100;
+    const activeCount = visualState.particleCount;
+    // Initialize particle positions
+    const positions = useMemo(() => {
+        const pos = new Float32Array(maxParticles * 3);
+        const particles = [];
+        for (let i = 0; i < maxParticles; i++) {
+            const theta = Math.random() * Math.PI * 2;
+            const phi = Math.acos(2 * Math.random() - 1);
+            const radius = shellRadius * (MIN_RADIUS + Math.random() * (MAX_RADIUS - MIN_RADIUS));
+            const speed = 0.3 + Math.random() * 0.7;
+            const x = radius * Math.sin(phi) * Math.cos(theta);
+            const y = radius * Math.sin(phi) * Math.sin(theta);
+            const z = radius * Math.cos(phi);
+            pos[i * 3] = x;
+            pos[i * 3 + 1] = y;
+            pos[i * 3 + 2] = z;
+            particles.push({ theta, phi, radius, speed });
+        }
+        particlesRef.current = particles;
+        return pos;
+    }, [shellRadius]);
+    // Particle color from emotion hue
+    const particleColor = useMemo(() => {
+        const hue = visualState.coreHue / 360;
+        const sat = visualState.coreSaturation * 0.8;
+        return new THREE.Color().setHSL(hue, sat, 0.6);
+    }, [visualState.coreHue, visualState.coreSaturation]);
+    useFrame(() => {
+        if (!pointsRef.current)
+            return;
+        const posAttr = pointsRef.current.geometry.attributes.position;
+        const positionsArray = posAttr.array;
+        const flowDir = visualState.particleFlowDirection;
+        const velocity = visualState.particleVelocity;
+        for (let i = 0; i < maxParticles; i++) {
+            const particle = particlesRef.current[i];
+            const idx = i * 3;
+            // Hide particles beyond active count
+            if (i >= activeCount) {
+                positionsArray[idx] = 0;
+                positionsArray[idx + 1] = 0;
+                positionsArray[idx + 2] = 1000; // Far away
+                continue;
+            }
+            const x = positionsArray[idx];
+            const y = positionsArray[idx + 1];
+            const z = positionsArray[idx + 2];
+            const r = Math.sqrt(x * x + y * y + z * z);
+            if (r < 0.001)
+                continue;
+            // Normalize
+            const nx = x / r;
+            const ny = y / r;
+            const nz = z / r;
+            // Move radially based on flow direction and velocity
+            const movement = flowDir * velocity * particle.speed * 0.06;
+            const newR = r + movement;
+            // Update position
+            positionsArray[idx] = nx * newR;
+            positionsArray[idx + 1] = ny * newR;
+            positionsArray[idx + 2] = nz * newR;
+            // Reset if out of bounds
+            const minR = shellRadius * INNER_BOUND;
+            const maxR = shellRadius * OUTER_BOUND;
+            if (newR > maxR || newR < minR) {
+                const theta = Math.random() * Math.PI * 2;
+                const phi = Math.acos(2 * Math.random() - 1);
+                const spawnR = shellRadius * (MIN_RADIUS + Math.random() * (MAX_RADIUS - MIN_RADIUS));
+                positionsArray[idx] = spawnR * Math.sin(phi) * Math.cos(theta);
+                positionsArray[idx + 1] = spawnR * Math.sin(phi) * Math.sin(theta);
+                positionsArray[idx + 2] = spawnR * Math.cos(phi);
+            }
+        }
+        posAttr.needsUpdate = true;
+    });
+    if (activeCount === 0)
+        return null;
+    return (_jsxs("points", { ref: pointsRef, children: [_jsx("bufferGeometry", { children: _jsx("bufferAttribute", { attach: "attributes-position", args: [positions, 3] }) }), _jsx("pointsMaterial", { color: particleColor, size: 0.03, transparent: true, opacity: 0.7 * visualState.overallIntensity, blending: THREE.AdditiveBlending, depthWrite: false, sizeAttenuation: true, toneMapped: false })] }));
+}

package/dist/primitives/three/CrystallineOrganism/OrganismShell.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OrganismShell - Emotion-Driven Crystalline Shell
+ *
+ * Renders faceted crystalline shells driven by the AVO emotion system.
+ * Visual properties (color, glow, rotation, breathing) all derive from VisualState.
+ */
+import type { OrganismShellProps } from "./types";
+export declare function OrganismShell({ type, visualState, size, selected, hovered, }: OrganismShellProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=OrganismShell.d.ts.map

package/dist/primitives/three/CrystallineOrganism/OrganismShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrganismShell.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/CrystallineOrganism/OrganismShell.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA2BlD,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,WAAW,EACX,IAAI,EACJ,QAAgB,EAChB,OAAe,GAChB,EAAE,kBAAkB,2CAwOpB"}

package/dist/primitives/three/CrystallineOrganism/OrganismShell.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * OrganismShell - Emotion-Driven Crystalline Shell
+ *
+ * Renders faceted crystalline shells driven by the AVO emotion system.
+ * Visual properties (color, glow, rotation, breathing) all derive from VisualState.
+ */
+import { useRef, useMemo } from "react";
+import { useFrame } from "@react-three/fiber";
+import * as THREE from "three";
+import { ORGANISM_GEOMETRY, ANIMATION_CONFIG, CRYSTALLINE_CONFIG, } from "./constants";
+// Geometry factory - creates the appropriate platonic solid
+function createGeometry(type, size) {
+    switch (type) {
+        case "octahedron":
+            return new THREE.OctahedronGeometry(size, 0);
+        case "icosahedron":
+            return new THREE.IcosahedronGeometry(size, 0);
+        case "dodecahedron":
+            return new THREE.DodecahedronGeometry(size, 0);
+        case "tetrahedron":
+            return new THREE.TetrahedronGeometry(size, 0);
+        case "box":
+            return new THREE.BoxGeometry(size * 1.4, size * 1.4, size * 1.4);
+        case "torus":
+            return new THREE.TorusGeometry(size, size * 0.35, 8, 24);
+        default:
+            return new THREE.IcosahedronGeometry(size, 0);
+    }
+}
+export function OrganismShell({ type, visualState, size, selected = false, hovered = false, }) {
+    const groupRef = useRef(null);
+    const shellRef = useRef(null);
+    const edgesRef = useRef(null);
+    const coreRef = useRef(null);
+    const lightRef = useRef(null);
+    const targetScaleRef = useRef(new THREE.Vector3(1, 1, 1));
+    const geometryType = ORGANISM_GEOMETRY[type];
+    // Main shell geometry
+    const shellGeometry = useMemo(() => createGeometry(geometryType, size), [geometryType, size]);
+    // Edges geometry for Tron-like glow
+    const edgesGeometry = useMemo(() => new THREE.EdgesGeometry(shellGeometry, 15), [shellGeometry]);
+    // Derive colors from emotion state
+    const { coreColor, edgeColor, isError } = useMemo(() => {
+        const hue = visualState.coreHue / 360;
+        const sat = visualState.coreSaturation;
+        // Core color from emotion hue
+        const core = new THREE.Color().setHSL(hue, sat, 0.55);
+        // Edge color slightly lighter/more emissive
+        const edge = new THREE.Color().setHSL(hue, sat * 0.9, 0.6);
+        // Detect error state (low valence + high arousal typically = error zone)
+        // coreHue around 220 (blue) = negative valence area
+        const error = visualState.coreHue > 180 && visualState.emissiveIntensity > 0.6;
+        return { coreColor: core, edgeColor: edge, isError: error };
+    }, [visualState.coreHue, visualState.coreSaturation, visualState.emissiveIntensity]);
+    // Light intensity from emotion
+    const lightIntensity = useMemo(() => {
+        return CRYSTALLINE_CONFIG.baseLightIntensity * visualState.overallIntensity;
+    }, [visualState.overallIntensity]);
+    useFrame(({ clock }, delta) => {
+        const group = groupRef.current;
+        const edges = edgesRef.current;
+        const core = coreRef.current;
+        const light = lightRef.current;
+        if (!group)
+            return;
+        const t = clock.elapsedTime;
+        const scaleAlpha = 1 - Math.exp(-delta * 12);
+        // Base scale from emotion scaleFactor
+        let targetScale = visualState.scaleFactor;
+        // Interaction scale modifiers
+        if (selected) {
+            targetScale *= ANIMATION_CONFIG.select.scaleFactor;
+        }
+        else if (hovered) {
+            targetScale *= ANIMATION_CONFIG.hover.scaleFactor;
+        }
+        // Breathing animation from emotion breathingRate/Amplitude
+        const breathPhase = t * visualState.breathingRate + visualState.breathingPhaseBias;
+        targetScale += visualState.breathingAmplitude * Math.sin(breathPhase);
+        // Motion noise for low valence (uncertainty)
+        if (visualState.motionNoise > 0) {
+            targetScale += visualState.motionNoise * Math.sin(t * 8) * Math.cos(t * 11);
+        }
+        targetScaleRef.current.setScalar(targetScale);
+        group.scale.lerp(targetScaleRef.current, scaleAlpha);
+        // Rotation from ringRotationSpeed
+        group.rotation.y += delta * visualState.ringRotationSpeed * 0.15;
+        group.rotation.x += delta * visualState.ringRotationSpeed * 0.08;
+        // Edge glow pulsing from glowPulseRate
+        const pulse = 0.6 + 0.4 * Math.sin(t * visualState.glowPulseRate * Math.PI * 2);
+        if (edges?.material && "opacity" in edges.material) {
+            const mat = edges.material;
+            mat.opacity = 0.5 + pulse * 0.5 * visualState.emissiveIntensity;
+        }
+        // Core pulsing (faster than shell)
+        if (core) {
+            const coreScale = 0.9 + 0.2 * Math.sin(t * visualState.glowPulseRate * Math.PI * 3);
+            core.scale.setScalar(coreScale);
+        }
+        // Light intensity pulsing
+        if (light) {
+            light.intensity = lightIntensity * (0.7 + 0.3 * pulse);
+        }
+    });
+    // Shell material properties from emotion
+    const shellOpacity = 0.3 + visualState.emissiveIntensity * 0.3;
+    const shellTransmission = 0.4 + (1 - visualState.emissiveIntensity) * 0.3;
+    return (_jsxs("group", { ref: groupRef, children: [_jsxs("mesh", { ref: coreRef, children: [_jsx("sphereGeometry", { args: [size * 0.2, 16, 16] }), _jsx("meshStandardMaterial", { color: coreColor, emissive: coreColor, emissiveIntensity: 1.2 + visualState.emissiveIntensity, toneMapped: false, transparent: true, opacity: 0.9 })] }), _jsx("pointLight", { ref: lightRef, position: [0, 0, 0], intensity: lightIntensity, distance: size * CRYSTALLINE_CONFIG.coreGlowRadius, decay: 2, color: coreColor }), _jsx("mesh", { ref: shellRef, geometry: shellGeometry, children: _jsx("meshPhysicalMaterial", { color: edgeColor, transparent: true, opacity: shellOpacity, transmission: shellTransmission, roughness: 0.15, metalness: 0.2, ior: 1.5, thickness: size * 0.3, side: THREE.DoubleSide, envMapIntensity: 0.4 }) }), _jsx("lineSegments", { ref: edgesRef, geometry: edgesGeometry, children: _jsx("lineBasicMaterial", { color: edgeColor, transparent: true, opacity: 0.8, linewidth: 2, toneMapped: false, blending: THREE.AdditiveBlending, depthWrite: false }) }), _jsxs("mesh", { scale: visualState.auraExpansion, children: [_jsx("sphereGeometry", { args: [size * 1.1, 24, 24] }), _jsx("meshStandardMaterial", { color: edgeColor, transparent: true, opacity: 0.06 * visualState.overallIntensity + (selected ? 0.06 : 0) + (hovered ? 0.03 : 0), emissive: edgeColor, emissiveIntensity: 0.2, side: THREE.BackSide, depthWrite: false })] }), selected && (_jsxs("group", { rotation: [Math.PI / 2, 0, 0], children: [_jsxs("mesh", { children: [_jsx("torusGeometry", { args: [size * 1.4, size * 0.018, 8, 48] }), _jsx("meshStandardMaterial", { color: CRYSTALLINE_CONFIG.selectionRing, emissive: CRYSTALLINE_CONFIG.selectionRing, emissiveIntensity: 1.5, toneMapped: false, transparent: true, opacity: 0.9 })] }), _jsxs("mesh", { rotation: [visualState.ringTilt * 0.02, 0, 0.4], children: [_jsx("torusGeometry", { args: [size * 1.25, size * 0.012, 8, 48] }), _jsx("meshStandardMaterial", { color: CRYSTALLINE_CONFIG.selectionRing, emissive: CRYSTALLINE_CONFIG.selectionRing, emissiveIntensity: 1.0, toneMapped: false, transparent: true, opacity: 0.6 })] })] })), hovered && !selected && (_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [size * 1.25, 24, 24] }), _jsx("meshBasicMaterial", { color: edgeColor, transparent: true, opacity: 0.12, side: THREE.BackSide, blending: THREE.AdditiveBlending, depthWrite: false })] })), isError && (_jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [size * 1.3, 16, 16] }), _jsx("meshBasicMaterial", { color: CRYSTALLINE_CONFIG.errorGlow, transparent: true, opacity: 0.08 + visualState.motionNoise * 0.15, side: THREE.BackSide, blending: THREE.AdditiveBlending, depthWrite: false })] }))] }));
+}

package/dist/primitives/three/CrystallineOrganism/constants.d.ts

@@ -0,0 +1,84 @@
+/**
+ * CrystallineOrganism Constants
+ *
+ * Geometry and visual configuration for organism types.
+ * Visual behavior (colors, pulsing, particles) comes from the AVO emotion system.
+ */
+import type { OrganismType, OrganismState } from "./types";
+import type { AnchorState } from "../../../emotion/types";
+export type GeometryType = "octahedron" | "icosahedron" | "dodecahedron" | "tetrahedron" | "box" | "torus";
+export declare const ORGANISM_GEOMETRY: Record<OrganismType, GeometryType>;
+export declare const ORGANISM_BASE_SIZE: Record<OrganismType, number>;
+/**
+ * Maps OrganismState to AnchorState for emotion system integration
+ */
+export declare const ORGANISM_STATE_MAP: Record<OrganismState, AnchorState>;
+export declare const CRYSTALLINE_CONFIG: {
+    readonly energyCore: "#f2c96b";
+    readonly energyCoreEmissive: "#d4a84b";
+    readonly structuralBlue: "#6b8cbe";
+    readonly structuralEmissive: "#9bb4e3";
+    readonly selectionRing: "#00f0ff";
+    readonly hoverGlow: "#6b8cbe";
+    readonly errorCore: "#ff3366";
+    readonly errorGlow: "#ff0055";
+    readonly offlineCore: "#4a6fa5";
+    readonly baseLightIntensity: 0.8;
+    readonly coreGlowRadius: 6;
+};
+export declare const ANIMATION_CONFIG: {
+    readonly hover: {
+        readonly scaleFactor: 1.1;
+        readonly duration: 150;
+    };
+    readonly select: {
+        readonly scaleFactor: 1.15;
+        readonly duration: 200;
+    };
+    readonly sprawl: {
+        readonly shellExpandDuration: 150;
+        readonly childrenStaggerDelay: 30;
+        readonly childrenAnimateDuration: 250;
+        readonly latticeFormDelay: 250;
+        readonly latticeFormDuration: 150;
+        readonly totalDuration: 500;
+    };
+};
+export declare const HEX_GRID_CONFIG: {
+    readonly size: 1.2;
+    readonly height: 0;
+    readonly maxRadius: 5;
+};
+export declare const EDGE_STYLES: {
+    readonly hierarchy: {
+        readonly lineWidth: 2;
+        readonly dashArray: null;
+        readonly particleFlow: false;
+        readonly pulseGlow: false;
+    };
+    readonly "data-flow": {
+        readonly lineWidth: 1.5;
+        readonly dashArray: null;
+        readonly particleFlow: true;
+        readonly pulseGlow: false;
+    };
+    readonly dependency: {
+        readonly lineWidth: 1;
+        readonly dashArray: readonly [0.1, 0.05];
+        readonly particleFlow: false;
+        readonly pulseGlow: false;
+    };
+    readonly communication: {
+        readonly lineWidth: 1.5;
+        readonly dashArray: null;
+        readonly particleFlow: false;
+        readonly pulseGlow: true;
+    };
+    readonly speculative: {
+        readonly lineWidth: 1;
+        readonly dashArray: readonly [0.03, 0.03];
+        readonly particleFlow: false;
+        readonly pulseGlow: true;
+    };
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/primitives/three/CrystallineOrganism/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/CrystallineOrganism/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAM1D,MAAM,MAAM,YAAY,GACpB,YAAY,GACZ,aAAa,GACb,cAAc,GACd,aAAa,GACb,KAAK,GACL,OAAO,CAAC;AAEZ,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,YAAY,EAAE,YAAY,CAQvD,CAAC;AAEX,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAQlD,CAAC;AAMX;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,aAAa,EAAE,WAAW,CASxD,CAAC;AAMX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;CAuBrB,CAAC;AAMX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAoBnB,CAAC;AAMX,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAMX,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Bd,CAAC"}

package/dist/primitives/three/CrystallineOrganism/constants.js

@@ -0,0 +1,128 @@
+/**
+ * CrystallineOrganism Constants
+ *
+ * Geometry and visual configuration for organism types.
+ * Visual behavior (colors, pulsing, particles) comes from the AVO emotion system.
+ */
+export const ORGANISM_GEOMETRY = {
+    kernel: "octahedron",
+    agent: "icosahedron",
+    workcell: "dodecahedron",
+    task: "tetrahedron",
+    storage: "box",
+    relay: "torus",
+    swarm: "icosahedron", // swarm uses icosahedron at large scale
+};
+export const ORGANISM_BASE_SIZE = {
+    kernel: 0.6,
+    agent: 0.45,
+    workcell: 0.5,
+    task: 0.35,
+    storage: 0.4,
+    relay: 0.35,
+    swarm: 0.8,
+};
+// -----------------------------------------------------------------------------
+// State Mapping
+// -----------------------------------------------------------------------------
+/**
+ * Maps OrganismState to AnchorState for emotion system integration
+ */
+export const ORGANISM_STATE_MAP = {
+    idle: "idle",
+    listening: "listening",
+    thinking: "thinking",
+    responding: "responding",
+    success: "satisfied",
+    error: "error",
+    sleep: "dormant",
+    busy: "focused",
+};
+// -----------------------------------------------------------------------------
+// Crystalline Tech Aesthetic
+// -----------------------------------------------------------------------------
+export const CRYSTALLINE_CONFIG = {
+    // Core energy colors (Backbay gold/amber palette)
+    energyCore: "#f2c96b",
+    energyCoreEmissive: "#d4a84b",
+    // Structural colors (Backbay steel blue)
+    structuralBlue: "#6b8cbe",
+    structuralEmissive: "#9bb4e3",
+    // Selection/interaction
+    selectionRing: "#00f0ff",
+    hoverGlow: "#6b8cbe",
+    // Error state
+    errorCore: "#ff3366",
+    errorGlow: "#ff0055",
+    // Offline state
+    offlineCore: "#4a6fa5",
+    // Light configuration
+    baseLightIntensity: 0.8,
+    coreGlowRadius: 6,
+};
+// -----------------------------------------------------------------------------
+// Animation Timing
+// -----------------------------------------------------------------------------
+export const ANIMATION_CONFIG = {
+    // Interaction
+    hover: {
+        scaleFactor: 1.1,
+        duration: 150,
+    },
+    select: {
+        scaleFactor: 1.15,
+        duration: 200,
+    },
+    // Sprawl transition
+    sprawl: {
+        shellExpandDuration: 150,
+        childrenStaggerDelay: 30,
+        childrenAnimateDuration: 250,
+        latticeFormDelay: 250,
+        latticeFormDuration: 150,
+        totalDuration: 500,
+    },
+};
+// -----------------------------------------------------------------------------
+// Hex Grid Layout
+// -----------------------------------------------------------------------------
+export const HEX_GRID_CONFIG = {
+    size: 1.2,
+    height: 0,
+    maxRadius: 5,
+};
+// -----------------------------------------------------------------------------
+// Lattice Edge Styles
+// -----------------------------------------------------------------------------
+export const EDGE_STYLES = {
+    hierarchy: {
+        lineWidth: 2,
+        dashArray: null,
+        particleFlow: false,
+        pulseGlow: false,
+    },
+    "data-flow": {
+        lineWidth: 1.5,
+        dashArray: null,
+        particleFlow: true,
+        pulseGlow: false,
+    },
+    dependency: {
+        lineWidth: 1,
+        dashArray: [0.1, 0.05],
+        particleFlow: false,
+        pulseGlow: false,
+    },
+    communication: {
+        lineWidth: 1.5,
+        dashArray: null,
+        particleFlow: false,
+        pulseGlow: true,
+    },
+    speculative: {
+        lineWidth: 1,
+        dashArray: [0.03, 0.03],
+        particleFlow: false,
+        pulseGlow: true,
+    },
+};

package/dist/primitives/three/CrystallineOrganism/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * CrystallineOrganism
+ *
+ * Emotion-driven 3D visualization primitive for units of work.
+ * Uses the AVO emotion system shared with the Glyph.
+ */
+export * from "./types";
+export * from "./constants";
+export { CrystallineOrganism } from "./CrystallineOrganism";
+export { OrganismShell } from "./OrganismShell";
+export { OrganismParticles } from "./OrganismParticles";
+export { useOrganismEmotion } from "./useOrganismEmotion";
+export { OrganismLattice } from "./OrganismLattice";
+export { LatticeEdge } from "./LatticeEdge";
+export { Breadcrumb } from "./Breadcrumb";
+export * from "./layouts";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/CrystallineOrganism/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/CrystallineOrganism/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,WAAW,CAAC"}

package/dist/primitives/three/CrystallineOrganism/index.js

@@ -0,0 +1,16 @@
+/**
+ * CrystallineOrganism
+ *
+ * Emotion-driven 3D visualization primitive for units of work.
+ * Uses the AVO emotion system shared with the Glyph.
+ */
+export * from "./types";
+export * from "./constants";
+export { CrystallineOrganism } from "./CrystallineOrganism";
+export { OrganismShell } from "./OrganismShell";
+export { OrganismParticles } from "./OrganismParticles";
+export { useOrganismEmotion } from "./useOrganismEmotion";
+export { OrganismLattice } from "./OrganismLattice";
+export { LatticeEdge } from "./LatticeEdge";
+export { Breadcrumb } from "./Breadcrumb";
+export * from "./layouts";

package/dist/primitives/three/CrystallineOrganism/layouts/hexGrid.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hex Grid Layout
+ *
+ * Positions organisms on hex grid intersections radiating from center.
+ */
+import type { HexGridPosition, LayoutResult } from "../types";
+/**
+ * Convert axial coordinates (q, r) to world position (x, z)
+ */
+export declare function axialToWorld(q: number, r: number): [number, number];
+/**
+ * Get hex positions in a spiral pattern from center
+ */
+export declare function getHexSpiral(count: number): HexGridPosition[];
+/**
+ * Layout organisms on hex grid
+ */
+export declare function hexGridLayout(organismIds: string[]): LayoutResult;
+//# sourceMappingURL=hexGrid.d.ts.map

package/dist/primitives/three/CrystallineOrganism/layouts/hexGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexGrid.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/three/CrystallineOrganism/layouts/hexGrid.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG9D;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAKnE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,EAAE,CA6C7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,YAAY,CAYjE"}

package/dist/primitives/three/CrystallineOrganism/layouts/hexGrid.js

@@ -0,0 +1,71 @@
+/**
+ * Hex Grid Layout
+ *
+ * Positions organisms on hex grid intersections radiating from center.
+ */
+import { HEX_GRID_CONFIG } from "../constants";
+/**
+ * Convert axial coordinates (q, r) to world position (x, z)
+ */
+export function axialToWorld(q, r) {
+    const { size } = HEX_GRID_CONFIG;
+    const x = size * (Math.sqrt(3) * q + (Math.sqrt(3) / 2) * r);
+    const z = size * (3 / 2) * r;
+    return [x, z];
+}
+/**
+ * Get hex positions in a spiral pattern from center
+ */
+export function getHexSpiral(count) {
+    const positions = [];
+    // Center position
+    positions.push({ q: 0, r: 0, x: 0, z: 0 });
+    if (count <= 1)
+        return positions;
+    // Spiral outward
+    let q = 0;
+    let r = 0;
+    let ring = 1;
+    // Direction vectors for hex movement
+    const directions = [
+        [1, 0], // E
+        [0, 1], // SE
+        [-1, 1], // SW
+        [-1, 0], // W
+        [0, -1], // NW
+        [1, -1], // NE
+    ];
+    while (positions.length < count) {
+        // Start each ring at (ring, 0)
+        q = ring;
+        r = 0;
+        for (let dir = 0; dir < 6; dir++) {
+            for (let step = 0; step < ring; step++) {
+                if (positions.length >= count)
+                    break;
+                const [wx, wz] = axialToWorld(q, r);
+                positions.push({ q, r, x: wx, z: wz });
+                q += directions[dir][0];
+                r += directions[dir][1];
+            }
+        }
+        ring++;
+        if (ring > HEX_GRID_CONFIG.maxRadius)
+            break;
+    }
+    return positions.slice(0, count);
+}
+/**
+ * Layout organisms on hex grid
+ */
+export function hexGridLayout(organismIds) {
+    const hexPositions = getHexSpiral(organismIds.length);
+    const positions = new Map();
+    organismIds.forEach((id, i) => {
+        const hex = hexPositions[i];
+        if (hex) {
+            positions.set(id, [hex.x, HEX_GRID_CONFIG.height, hex.z]);
+        }
+    });
+    return { positions };
+}

package/dist/primitives/three/CrystallineOrganism/layouts/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./hexGrid";
+//# sourceMappingURL=index.d.ts.map

package/dist/primitives/three/CrystallineOrganism/layouts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/primitives/three/CrystallineOrganism/layouts/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

package/dist/primitives/three/CrystallineOrganism/layouts/index.js

@@ -0,0 +1 @@
+export * from "./hexGrid";