@buley/hexgrid-3d 1.0.0 → 1.1.1

package/src/adapters/DashAdapter.ts

@@ -0,0 +1,57 @@
+/**
+ * Adapter for Zero-Copy Data Sync between Dash 2.0 and HexGrid-3D.
+ * 
+ * This adapter subscribes to a Dash "LiveQuery" which returns pointers to shared memory (SharedArrayBuffer)
+ * or Float32Arrays. It then syncs this data directly to the HexGridWasm instance.
+ */
+
+// Placeholder types until we link the actual Dash package
+interface DashQueryHandle {
+  ptr: number;
+  size: number;
+  buffer: SharedArrayBuffer | ArrayBuffer;
+}
+
+export class DashAdapter {
+  private dash: any; // Will be typed when we link @buley/dash
+
+  constructor(dashInstance: any) {
+    this.dash = dashInstance;
+  }
+
+  /**
+   * Subscribe to a semantic query in Dash and sync results to HexGrid.
+   * 
+   * @param query The vector search query
+   * @param gridInstance The WASM instance of the HexGrid
+   */
+  bindSemanticSearch(query: string, particleSystem: any) {
+    console.log('[DashAdapter] Binding semantic search:', query);
+    
+    // Hypothetical Zero-Copy API from Dash 2.0
+    if (this.dash.liveQueryPtr) {
+       this.dash.liveQueryPtr(`SELECT embedding FROM dash_vec_idx WHERE embedding MATCH '${query}'`).subscribe((handle: DashQueryHandle) => {
+          console.log(`[DashAdapter] Received ${handle.size} bytes from Dash.`);
+          
+          // Assume the handle.buffer contains [pos, color, scale] interleaved or tightly packed
+          // For this MVP, we treat it as just positions
+          const floatView = new Float32Array(handle.buffer);
+          
+          // Zero-Copy Injection logic would go here
+          // We can't strictly "inject" one buffer into 3 separate Float32Arrays unless they are contiguous in the SAB
+          // or we create views into offsets.
+          
+          // Hypothetical offset logic:
+          const count = handle.size / 4 / 7; // pos + color + scale = 3+3+1 = 7 floats
+          
+          // particleSystem.setSharedBuffers({
+          //     positions: floatView.subarray(0, count * 3),
+          //     colors: floatView.subarray(count * 3, count * 6),
+          //     scales: floatView.subarray(count * 6, count * 7)
+          // });
+       });
+    } else {
+       console.warn('[DashAdapter] Dash instance does not support Zero-Copy liveQueryPtr yet.');
+    }
+  }
+}

package/src/adapters.ts

@@ -2,7 +2,7 @@
  * Type-safe adapter pattern for converting domain objects to GridItems
  */
 
-import type { GridItem } from './types'
+import type { GridItem } from './types';
 
 /**
  * Options for adapter conversion
@@ -11,15 +11,15 @@ export interface AdapterOptions {
   /**
    * Custom velocity calculation override
    */
-  velocity?: number
+  velocity?: number;
   /**
    * Custom visual URL override
    */
-  visualUrl?: string
+  visualUrl?: string;
   /**
    * Additional metadata to merge
    */
-  metadata?: Record<string, unknown>
+  metadata?: Record<string, unknown>;
 }
 
 /**
@@ -29,37 +29,35 @@ export interface ItemAdapter<T> {
   /**
    * Convert a domain object to a GridItem
    */
-  toGridItem(data: T, options?: AdapterOptions): GridItem<T>
+  toGridItem(data: T, options?: AdapterOptions): GridItem<T>;
   /**
    * Extract the original domain object from a GridItem
    */
-  fromGridItem(item: GridItem<T>): T
+  fromGridItem(item: GridItem<T>): T;
   /**
    * Calculate velocity for the item (optional)
    */
-  calculateVelocity?(data: T): number
+  calculateVelocity?(data: T): number;
   /**
    * Extract visual URL for the item (optional)
    */
-  extractVisualUrl?(data: T): string | undefined
+  extractVisualUrl?(data: T): string | undefined;
 }
 
 /**
  * Helper to create adapters for common patterns
  */
-export function createAdapter<T>(
-  config: {
-    type: string
-    toGridItem: (data: T, options?: AdapterOptions) => GridItem<T>
-    fromGridItem: (item: GridItem<T>) => T
-    calculateVelocity?: (data: T) => number
-    extractVisualUrl?: (data: T) => string | undefined
-  }
-): ItemAdapter<T> {
+export function createAdapter<T>(config: {
+  type: string;
+  toGridItem: (data: T, options?: AdapterOptions) => GridItem<T>;
+  fromGridItem: (item: GridItem<T>) => T;
+  calculateVelocity?: (data: T) => number;
+  extractVisualUrl?: (data: T) => string | undefined;
+}): ItemAdapter<T> {
   return {
     toGridItem: config.toGridItem,
     fromGridItem: config.fromGridItem,
     calculateVelocity: config.calculateVelocity,
     extractVisualUrl: config.extractVisualUrl,
-  }
+  };
 }

package/src/algorithms/AdvancedStatistics.ts

@@ -21,10 +21,12 @@ export function theilIndex(values: number[]): number {
   if (values.length === 0) return 0;
   const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
   if (avg === 0) return 0;
-  return values.reduce((sum, val) => {
-    const ratio = val / avg;
-    return sum + (ratio === 0 ? 0 : ratio * Math.log(ratio));
-  }, 0) / values.length;
+  return (
+    values.reduce((sum, val) => {
+      const ratio = val / avg;
+      return sum + (ratio === 0 ? 0 : ratio * Math.log(ratio));
+    }, 0) / values.length
+  );
 }
 
 export function atkinsonIndex(values: number[], epsilon: number): number {
@@ -45,7 +47,10 @@ export function atkinsonIndex(values: number[], epsilon: number): number {
   return 1 - eq / avg;
 }
 
-export function paretoRatio(values: number[], topFraction: number): {
+export function paretoRatio(
+  values: number[],
+  topFraction: number
+): {
   ratioHeld: number;
   paretoIndex: number;
 } {
@@ -126,7 +131,7 @@ export function detectTrend(values: number[]): TrendResult {
   let den = 0;
   let ssRes = 0;
   let ssTot = 0;
-  
+
   for (let i = 0; i < n; i++) {
     const dx = i - xMean;
     num += dx * (values[i] - yMean);
@@ -134,7 +139,7 @@ export function detectTrend(values: number[]): TrendResult {
   }
   const slope = den === 0 ? 0 : num / den;
   const intercept = yMean - slope * xMean;
-  
+
   // Calculate R-squared
   for (let i = 0; i < n; i++) {
     const predicted = slope * i + intercept;
@@ -142,8 +147,9 @@ export function detectTrend(values: number[]): TrendResult {
     ssTot += Math.pow(values[i] - yMean, 2);
   }
   const rSquared = ssTot === 0 ? 0 : 1 - ssRes / ssTot;
-  
-  const direction = slope > 0.1 ? 'increasing' : slope < -0.1 ? 'decreasing' : 'stable';
+
+  const direction =
+    slope > 0.1 ? 'increasing' : slope < -0.1 ? 'decreasing' : 'stable';
   return { slope, direction, rSquared };
 }
 
@@ -151,7 +157,8 @@ export function detectChangePoints(values: number[]): number[] {
   if (values.length < 3) return [];
   const changes: number[] = [];
   const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
-  const variance = values.reduce((sum, val) => sum + (val - avg) ** 2, 0) / values.length;
+  const variance =
+    values.reduce((sum, val) => sum + (val - avg) ** 2, 0) / values.length;
   const threshold = Math.sqrt(variance) * 1.5;
   for (let i = 1; i < values.length; i++) {
     if (Math.abs(values[i] - values[i - 1]) > threshold) {
@@ -173,7 +180,10 @@ export function movingAverage(values: number[], windowSize: number): number[] {
   return result;
 }
 
-export function exponentialMovingAverage(values: number[], alpha: number): number[] {
+export function exponentialMovingAverage(
+  values: number[],
+  alpha: number
+): number[] {
   if (values.length === 0) return [];
   const result: number[] = [];
   let current = values[0] ?? 0;
@@ -205,7 +215,11 @@ export function sparkline(values: number[]): string {
     .join('');
 }
 
-export function sparklineSvg(values: number[], width: number = 100, height: number = 20): string {
+export function sparklineSvg(
+  values: number[],
+  width: number = 100,
+  height: number = 20
+): string {
   if (values.length === 0) return '';
   const min = Math.min(...values);
   const max = Math.max(...values);
@@ -254,32 +268,48 @@ export function hellingerDistance(p: number[], q: number[]): number {
 }
 
 // Double Exponential Smoothing (Holt's method)
-export function doubleExponentialSmoothing(values: number[], alpha: number = 0.3, beta: number = 0.1): number[] {
+export function doubleExponentialSmoothing(
+  values: number[],
+  alpha: number = 0.3,
+  beta: number = 0.1
+): number[] {
   if (values.length === 0) return [];
   const result: number[] = [];
   let level = values[0] ?? 0;
   let trend = 0;
-  
+
   result.push(level);
-  
+
   for (let i = 1; i < values.length; i++) {
     const prevLevel = level;
     level = alpha * values[i] + (1 - alpha) * (level + trend);
     trend = beta * (level - prevLevel) + (1 - beta) * trend;
     result.push(level + trend);
   }
-  
+
   return result;
 }
 
 // Euler Characteristic (simplified for 2D)
-export function eulerCharacteristic(vertices: number, edges: number, faces: number): number {
+export function eulerCharacteristic(
+  vertices: number,
+  edges: number,
+  faces: number
+): number {
   return vertices - edges + faces;
 }
 
 // Estimate Betti Numbers (simplified - returns basic topological invariants)
-export function estimateBettiNumbers(complex: { vertices: number; edges: number; faces: number }): { b0: number; b1: number } {
-  const euler = eulerCharacteristic(complex.vertices, complex.edges, complex.faces);
+export function estimateBettiNumbers(complex: {
+  vertices: number;
+  edges: number;
+  faces: number;
+}): { b0: number; b1: number } {
+  const euler = eulerCharacteristic(
+    complex.vertices,
+    complex.edges,
+    complex.faces
+  );
   // Simplified: b0 = number of connected components (assume 1 for now)
   // b1 = edges - vertices + 1 (for a connected graph)
   const b0 = 1;
@@ -303,7 +333,9 @@ export interface TerritoryStats {
   compactness: number;
 }
 
-export function computeTerritoryStats(territories: Array<{ area: number; perimeter: number }>): TerritoryStats {
+export function computeTerritoryStats(
+  territories: Array<{ area: number; perimeter: number }>
+): TerritoryStats {
   if (territories.length === 0) {
     return {
       totalTerritories: 0,
@@ -313,11 +345,13 @@ export function computeTerritoryStats(territories: Array<{ area: number; perimet
       compactness: 0,
     };
   }
-  
-  const sizes = territories.map(t => t.area);
+
+  const sizes = territories.map((t) => t.area);
   const totalSize = sizes.reduce((sum, s) => sum + s, 0);
-  const avgCompactness = territories.reduce((sum, t) => sum + compactness(t.area, t.perimeter), 0) / territories.length;
-  
+  const avgCompactness =
+    territories.reduce((sum, t) => sum + compactness(t.area, t.perimeter), 0) /
+    territories.length;
+
   return {
     totalTerritories: territories.length,
     averageSize: totalSize / territories.length,

package/src/algorithms/BayesianStatistics.ts

@@ -47,7 +47,12 @@ export class KalmanFilter {
   private processNoise: number;
   private measurementNoise: number;
 
-  constructor(initialState: number, initialUncertainty: number, processNoise: number, measurementNoise: number) {
+  constructor(
+    initialState: number,
+    initialUncertainty: number,
+    processNoise: number,
+    measurementNoise: number
+  ) {
     this.state = initialState;
     this.uncertainty = initialUncertainty;
     this.processNoise = processNoise;
@@ -56,7 +61,8 @@ export class KalmanFilter {
 
   update(measurement: number): void {
     const predictedUncertainty = this.uncertainty + this.processNoise;
-    const kalmanGain = predictedUncertainty / (predictedUncertainty + this.measurementNoise);
+    const kalmanGain =
+      predictedUncertainty / (predictedUncertainty + this.measurementNoise);
     this.state = this.state + kalmanGain * (measurement - this.state);
     this.uncertainty = (1 - kalmanGain) * predictedUncertainty;
   }
@@ -106,7 +112,10 @@ export function bayesianWinProbability(wins: number, losses: number): number {
   return wins / total;
 }
 
-export function bayesianConquestRate(successes: number, trials: number): number {
+export function bayesianConquestRate(
+  successes: number,
+  trials: number
+): number {
   if (trials === 0) return 0;
   return successes / trials;
 }
@@ -121,7 +130,9 @@ export interface ProbabilitySnapshot {
   probabilities: Array<{ label: string; probability: number }>;
 }
 
-export function generateProbabilitySnapshot(labels: string[]): ProbabilitySnapshot {
+export function generateProbabilitySnapshot(
+  labels: string[]
+): ProbabilitySnapshot {
   const probability = labels.length > 0 ? 1 / labels.length : 0;
   return {
     probabilities: labels.map((label) => ({ label, probability })),
@@ -138,7 +149,7 @@ export class DirichletDistribution {
 
   mean(): number[] {
     const sum = this.alphas.reduce((s, a) => s + a, 0);
-    return this.alphas.map(a => sum === 0 ? 0 : a / sum);
+    return this.alphas.map((a) => (sum === 0 ? 0 : a / sum));
   }
 }
 
@@ -222,19 +233,30 @@ export class HiddenMarkovModel {
 }
 
 // Bayesian A/B Test
-export function bayesianABTest(successA: number, trialsA: number, successB: number, trialsB: number): number {
+export function bayesianABTest(
+  successA: number,
+  trialsA: number,
+  successB: number,
+  trialsB: number
+): number {
   const probA = trialsA === 0 ? 0.5 : successA / trialsA;
   const probB = trialsB === 0 ? 0.5 : successB / trialsB;
   return probB - probA; // Difference in probabilities
 }
 
 // Bayes Factor
-export function bayesFactor(priorOdds: number, likelihoodRatio: number): number {
+export function bayesFactor(
+  priorOdds: number,
+  likelihoodRatio: number
+): number {
   return priorOdds * likelihoodRatio;
 }
 
 // MAP Estimate (Maximum A Posteriori)
-export function mapEstimate(data: number[], prior: { alpha: number; beta: number }): number {
+export function mapEstimate(
+  data: number[],
+  prior: { alpha: number; beta: number }
+): number {
   const sum = data.reduce((s, x) => s + x, 0);
   const n = data.length;
   const alpha = prior.alpha + sum;
@@ -252,7 +274,11 @@ export function learnMarkovChain(sequence: string[]): MarkovChain {
 }
 
 // Bootstrap Confidence Interval
-export function bootstrapConfidenceInterval(data: number[], iterations: number = 1000, confidence: number = 0.95): { lower: number; upper: number } {
+export function bootstrapConfidenceInterval(
+  data: number[],
+  iterations: number = 1000,
+  confidence: number = 0.95
+): { lower: number; upper: number } {
   const samples: number[] = [];
   for (let i = 0; i < iterations; i++) {
     const sample: number[] = [];
@@ -262,8 +288,8 @@ export function bootstrapConfidenceInterval(data: number[], iterations: number =
     samples.push(sample.reduce((s, x) => s + x, 0) / sample.length);
   }
   samples.sort((a, b) => a - b);
-  const lowerIdx = Math.floor((1 - confidence) / 2 * samples.length);
-  const upperIdx = Math.floor((1 + confidence) / 2 * samples.length);
+  const lowerIdx = Math.floor(((1 - confidence) / 2) * samples.length);
+  const upperIdx = Math.floor(((1 + confidence) / 2) * samples.length);
   return {
     lower: samples[lowerIdx] ?? 0,
     upper: samples[upperIdx] ?? 0,
@@ -271,7 +297,12 @@ export function bootstrapConfidenceInterval(data: number[], iterations: number =
 }
 
 // Monte Carlo Integration
-export function monteCarloIntegrate(fn: (x: number) => number, a: number, b: number, samples: number = 1000): number {
+export function monteCarloIntegrate(
+  fn: (x: number) => number,
+  a: number,
+  b: number,
+  samples: number = 1000
+): number {
   let sum = 0;
   for (let i = 0; i < samples; i++) {
     const x = a + Math.random() * (b - a);

package/src/algorithms/FlowField.ts

@@ -30,7 +30,13 @@ export class FlowField2D {
     this.sources = [];
   }
 
-  addSource(x: number, y: number, vx: number, vy: number, strength: number): void {
+  addSource(
+    x: number,
+    y: number,
+    vx: number,
+    vy: number,
+    strength: number
+  ): void {
     this.sources.push({ x, y, vx, vy, strength });
   }
 
@@ -55,7 +61,10 @@ export class FlowField2D {
     return new Vector2(vx, vy);
   }
 
-  sampleFull(x: number, y: number): { velocity: Vector2; divergence: number; curl: number } {
+  sampleFull(
+    x: number,
+    y: number
+  ): { velocity: Vector2; divergence: number; curl: number } {
     const velocity = this.sample(x, y);
     return {
       velocity,
@@ -64,7 +73,11 @@ export class FlowField2D {
     };
   }
 
-  traceStreamline(x: number, y: number, options: { maxLength: number; stepSize: number; maxSteps: number }): Streamline {
+  traceStreamline(
+    x: number,
+    y: number,
+    options: { maxLength: number; stepSize: number; maxSteps: number }
+  ): Streamline {
     const points: Vector2[] = [new Vector2(x, y)];
     let current = new Vector2(x, y);
     for (let i = 0; i < options.maxSteps; i++) {
@@ -106,7 +119,12 @@ export class HeatMap {
   private resolution: number;
   private data: Float32Array;
 
-  constructor(config: { width: number; height: number; resolution: number; kernelRadius: number }) {
+  constructor(config: {
+    width: number;
+    height: number;
+    resolution: number;
+    kernelRadius: number;
+  }) {
     this.width = Math.max(1, Math.round(config.width / config.resolution));
     this.height = Math.max(1, Math.round(config.height / config.resolution));
     this.resolution = config.resolution;
@@ -114,8 +132,14 @@ export class HeatMap {
   }
 
   addPoint(x: number, y: number, value: number): void {
-    const gridX = Math.min(this.width - 1, Math.max(0, Math.floor(x / this.resolution)));
-    const gridY = Math.min(this.height - 1, Math.max(0, Math.floor(y / this.resolution)));
+    const gridX = Math.min(
+      this.width - 1,
+      Math.max(0, Math.floor(x / this.resolution))
+    );
+    const gridY = Math.min(
+      this.height - 1,
+      Math.max(0, Math.floor(y / this.resolution))
+    );
     const index = gridY * this.width + gridX;
     this.data[index] += value;
   }