agentic-qe 3.7.21 → 3.8.0

package/dist/integrations/ruvector/temporal-compression.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Temporal Tensor Compression Service
+ * ADR-085: Temporal Tensor Pattern Compression
+ *
+ * Compresses pattern embeddings based on access patterns using tiered
+ * quantization. Hot patterns retain full precision, while cold patterns
+ * are aggressively compressed to save memory.
+ *
+ * TypeScript implementation using Int8Array (4x compression for all tiers).
+ * No native package exists — this IS the production implementation.
+ *
+ * Tiers (logical bit depths, stored as Int8Array):
+ * - HOT  (last 7 days):   8-bit quantization  (4x compression)
+ * - WARM (7-30 days):     5-bit quantization   (4x actual, 6.4x theoretical)
+ * - COLD (30+ days):      3-bit quantization   (4x actual, 10.7x theoretical)
+ *
+ * All tiers deliver 4x compression because Int8Array uses 1 byte per
+ * element regardless of logical bit depth.
+ *
+ * @module integrations/ruvector/temporal-compression
+ */
+/** Access-frequency tier for a pattern embedding */
+export type CompressionTier = 'hot' | 'warm' | 'cold';
+/**
+ * Compressed vector representation.
+ * Stores quantized data alongside the parameters needed for decompression.
+ */
+export interface CompressedVector {
+    /** Quantized integer data */
+    readonly data: Int8Array;
+    /** Scale factor used during quantization */
+    readonly scale: number;
+    /** Offset (minimum value) used during quantization */
+    readonly offset: number;
+    /** Compression tier applied */
+    readonly tier: CompressionTier;
+    /** Original vector dimensionality */
+    readonly originalLength: number;
+    /** Bit depth used for quantization */
+    readonly bitDepth: number;
+    /** Original byte size (float32 = 4 bytes per element) */
+    readonly originalByteSize: number;
+    /** Compressed byte size (actual storage: data.byteLength) */
+    readonly compressedByteSize: number;
+    /** Actual byte size in memory (always data.byteLength — 1 byte per Int8 element) */
+    readonly actualByteSize: number;
+    /** Theoretical byte size if true bit-packing were used (native only) */
+    readonly theoreticalByteSize: number;
+}
+/**
+ * Compression statistics for monitoring
+ */
+export interface CompressionStats {
+    /** Total vectors compressed */
+    totalCompressed: number;
+    /** Vectors by tier */
+    byTier: Record<CompressionTier, number>;
+    /** Average compression ratio per tier */
+    avgCompressionRatio: Record<CompressionTier, number>;
+    /** Total bytes saved */
+    totalBytesSaved: number;
+    /** Total original bytes */
+    totalOriginalBytes: number;
+    /** Total compressed bytes */
+    totalCompressedBytes: number;
+    /** Whether using native implementation */
+    usingNative: boolean;
+    /** Whether native bit-packing is in use (false in TS fallback) */
+    usesNativeBitPacking: boolean;
+}
+/** Hot tier: accessed within the last 7 days */
+declare const HOT_THRESHOLD_DAYS = 7;
+/** Warm tier: accessed within the last 30 days */
+declare const WARM_THRESHOLD_DAYS = 30;
+/** Quantization parameters per tier */
+declare const TIER_CONFIG: Record<CompressionTier, {
+    bitDepth: number;
+    min: number;
+    max: number;
+}>;
+/** Theoretical compression ratios assuming true bit-packing (native only) */
+declare const THEORETICAL_COMPRESSION_RATIOS: Record<CompressionTier, number>;
+/** Actual compression ratio in the TypeScript fallback (Float32 -> Int8 = 4x for all tiers) */
+declare const ACTUAL_FALLBACK_RATIO = 4;
+/**
+ * Temporal Compression Service
+ *
+ * Provides tiered quantization of pattern embedding vectors based on
+ * how recently they were accessed. Supports both a native Rust/NAPI
+ * implementation and a pure TypeScript fallback.
+ */
+export declare class TemporalCompressionService {
+    private stats;
+    /** Running sum of ratios per tier for average calculation */
+    private ratioSums;
+    private initialized;
+    /**
+     * Initialize the service, attempting to load the native module.
+     * Safe to call multiple times; subsequent calls are no-ops.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the temporal compression feature flag is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Classify a last-access date into a compression tier.
+     *
+     * @param lastAccessDate - When the pattern was last accessed
+     * @returns The compression tier for the pattern
+     */
+    classifyTier(lastAccessDate: Date): CompressionTier;
+    /**
+     * Compress a float32 embedding vector according to the specified tier.
+     *
+     * @param vector - The original float32 embedding
+     * @param tier - Compression tier to apply
+     * @returns Compressed vector with metadata for decompression
+     */
+    compress(vector: Float32Array, tier: CompressionTier): CompressedVector;
+    /**
+     * Decompress a compressed vector back to Float32Array.
+     *
+     * The output is an approximation of the original due to quantization loss.
+     * Consumers receive a standard Float32Array transparently.
+     *
+     * @param compressed - The compressed vector to restore
+     * @returns Reconstructed Float32Array
+     */
+    decompress(compressed: CompressedVector): Float32Array;
+    /**
+     * Get current compression statistics for monitoring.
+     */
+    getCompressionStats(): CompressionStats;
+    /**
+     * Reset compression statistics. Useful for testing or periodic reporting.
+     */
+    resetStats(): void;
+}
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns a value in [-1, 1] where 1 means identical direction.
+ */
+export declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * Get or create the shared TemporalCompressionService singleton.
+ */
+export declare function getTemporalCompressionService(): Promise<TemporalCompressionService>;
+/**
+ * Create a new TemporalCompressionService (non-singleton, for testing).
+ */
+export declare function createTemporalCompressionService(): TemporalCompressionService;
+/**
+ * Reset the shared singleton. Primarily for test cleanup.
+ */
+export declare function resetTemporalCompressionService(): void;
+export { TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS };
+/**
+ * @deprecated Use THEORETICAL_COMPRESSION_RATIOS instead.
+ * Kept for backwards compatibility with existing consumers.
+ */
+export declare const EXPECTED_COMPRESSION_RATIOS: Record<CompressionTier, number>;
+//# sourceMappingURL=temporal-compression.d.ts.map

package/dist/integrations/ruvector/temporal-compression.js

@@ -0,0 +1,318 @@
+/**
+ * Temporal Tensor Compression Service
+ * ADR-085: Temporal Tensor Pattern Compression
+ *
+ * Compresses pattern embeddings based on access patterns using tiered
+ * quantization. Hot patterns retain full precision, while cold patterns
+ * are aggressively compressed to save memory.
+ *
+ * TypeScript implementation using Int8Array (4x compression for all tiers).
+ * No native package exists — this IS the production implementation.
+ *
+ * Tiers (logical bit depths, stored as Int8Array):
+ * - HOT  (last 7 days):   8-bit quantization  (4x compression)
+ * - WARM (7-30 days):     5-bit quantization   (4x actual, 6.4x theoretical)
+ * - COLD (30+ days):      3-bit quantization   (4x actual, 10.7x theoretical)
+ *
+ * All tiers deliver 4x compression because Int8Array uses 1 byte per
+ * element regardless of logical bit depth.
+ *
+ * @module integrations/ruvector/temporal-compression
+ */
+import { LoggerFactory } from '../../logging/index.js';
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+const logger = LoggerFactory.create('temporal-compression');
+// ============================================================================
+// Constants
+// ============================================================================
+/** Hot tier: accessed within the last 7 days */
+const HOT_THRESHOLD_DAYS = 7;
+/** Warm tier: accessed within the last 30 days */
+const WARM_THRESHOLD_DAYS = 30;
+/** Quantization parameters per tier */
+const TIER_CONFIG = {
+    hot: { bitDepth: 8, min: -128, max: 127 },
+    warm: { bitDepth: 5, min: -16, max: 15 },
+    cold: { bitDepth: 3, min: -4, max: 3 },
+};
+/** Theoretical compression ratios assuming true bit-packing (native only) */
+const THEORETICAL_COMPRESSION_RATIOS = {
+    hot: 4.0, // 32-bit -> 8-bit = 4x
+    warm: 6.4, // 32-bit -> 5-bit ~ 6.4x
+    cold: 10.7, // 32-bit -> 3-bit ~ 10.7x
+};
+/** Actual compression ratio in the TypeScript fallback (Float32 -> Int8 = 4x for all tiers) */
+const ACTUAL_FALLBACK_RATIO = 4.0;
+// ============================================================================
+// Native module detection
+// ============================================================================
+/** Whether native ruvector-temporal-tensor is available */
+let nativeAvailable = null;
+let nativeModule = null;
+/**
+ * Check native module availability.
+ * No native package exists for temporal compression — always returns false.
+ * The TypeScript implementation IS the production implementation.
+ */
+async function tryLoadNativeModule() {
+    if (nativeAvailable !== null)
+        return nativeAvailable;
+    nativeAvailable = false;
+    nativeModule = null;
+    return false;
+}
+// ============================================================================
+// TypeScript Fallback Quantization
+// ============================================================================
+/**
+ * Quantize a float32 vector to the specified bit depth.
+ *
+ * Maps values linearly from [min, max] of the input to the integer range
+ * determined by the bit depth (stored as Int8Array for uniformity).
+ */
+function quantize(vector, tier) {
+    const config = TIER_CONFIG[tier];
+    const range = config.max - config.min; // integer range for this bit depth
+    if (vector.length === 0) {
+        return { data: new Int8Array(0), scale: 1, offset: 0 };
+    }
+    // Find min/max of input vector
+    let vMin = vector[0];
+    let vMax = vector[0];
+    for (let i = 1; i < vector.length; i++) {
+        if (vector[i] < vMin)
+            vMin = vector[i];
+        if (vector[i] > vMax)
+            vMax = vector[i];
+    }
+    // Avoid division by zero for constant vectors
+    const vRange = vMax - vMin;
+    const scale = vRange === 0 ? 1 : vRange / range;
+    const offset = vMin;
+    const data = new Int8Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        // Map float -> integer range, then shift to [config.min, config.max]
+        const normalized = vRange === 0 ? 0 : (vector[i] - offset) / scale;
+        let quantized = Math.round(normalized) + config.min;
+        // Clamp to valid range
+        quantized = Math.max(config.min, Math.min(config.max, quantized));
+        data[i] = quantized;
+    }
+    return { data, scale, offset };
+}
+/**
+ * Dequantize an Int8Array back to Float32Array using stored scale and offset.
+ */
+function dequantize(data, scale, offset, tier) {
+    const config = TIER_CONFIG[tier];
+    const result = new Float32Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        result[i] = (data[i] - config.min) * scale + offset;
+    }
+    return result;
+}
+// ============================================================================
+// Temporal Compression Service
+// ============================================================================
+/**
+ * Temporal Compression Service
+ *
+ * Provides tiered quantization of pattern embedding vectors based on
+ * how recently they were accessed. Supports both a native Rust/NAPI
+ * implementation and a pure TypeScript fallback.
+ */
+export class TemporalCompressionService {
+    stats = {
+        totalCompressed: 0,
+        byTier: { hot: 0, warm: 0, cold: 0 },
+        avgCompressionRatio: { hot: 0, warm: 0, cold: 0 },
+        totalBytesSaved: 0,
+        totalOriginalBytes: 0,
+        totalCompressedBytes: 0,
+        usingNative: false,
+        usesNativeBitPacking: false,
+    };
+    /** Running sum of ratios per tier for average calculation */
+    ratioSums = { hot: 0, warm: 0, cold: 0 };
+    initialized = false;
+    /**
+     * Initialize the service, attempting to load the native module.
+     * Safe to call multiple times; subsequent calls are no-ops.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        const native = await tryLoadNativeModule();
+        this.stats.usingNative = native;
+        this.stats.usesNativeBitPacking = native;
+        this.initialized = true;
+    }
+    /**
+     * Check if the temporal compression feature flag is enabled.
+     */
+    isEnabled() {
+        const flags = getRuVectorFeatureFlags();
+        return flags.useTemporalCompression === true;
+    }
+    /**
+     * Classify a last-access date into a compression tier.
+     *
+     * @param lastAccessDate - When the pattern was last accessed
+     * @returns The compression tier for the pattern
+     */
+    classifyTier(lastAccessDate) {
+        const now = Date.now();
+        const daysSinceAccess = (now - lastAccessDate.getTime()) / (1000 * 60 * 60 * 24);
+        if (daysSinceAccess < HOT_THRESHOLD_DAYS)
+            return 'hot';
+        if (daysSinceAccess < WARM_THRESHOLD_DAYS)
+            return 'warm';
+        return 'cold';
+    }
+    /**
+     * Compress a float32 embedding vector according to the specified tier.
+     *
+     * @param vector - The original float32 embedding
+     * @param tier - Compression tier to apply
+     * @returns Compressed vector with metadata for decompression
+     */
+    compress(vector, tier) {
+        const originalByteSize = vector.length * 4; // float32 = 4 bytes
+        let data;
+        let scale;
+        let offset;
+        if (nativeAvailable && nativeModule) {
+            const result = nativeModule.compress(vector, TIER_CONFIG[tier].bitDepth);
+            data = result.data;
+            scale = result.scale;
+            offset = result.offset;
+        }
+        else {
+            const result = quantize(vector, tier);
+            data = result.data;
+            scale = result.scale;
+            offset = result.offset;
+        }
+        const effectiveBitsPerElement = TIER_CONFIG[tier].bitDepth;
+        // Actual storage: Int8Array uses 1 byte per element regardless of logical bit depth.
+        // Theoretical: what a true bit-packing implementation would achieve.
+        const actualByteSize = data.byteLength;
+        const theoreticalByteSize = Math.ceil((vector.length * effectiveBitsPerElement) / 8);
+        const compressedByteSize = actualByteSize;
+        const ratio = compressedByteSize > 0 ? originalByteSize / compressedByteSize : 1;
+        // Update stats
+        this.stats.totalCompressed++;
+        this.stats.byTier[tier]++;
+        this.ratioSums[tier] += ratio;
+        this.stats.avgCompressionRatio[tier] = this.ratioSums[tier] / this.stats.byTier[tier];
+        this.stats.totalOriginalBytes += originalByteSize;
+        this.stats.totalCompressedBytes += compressedByteSize;
+        this.stats.totalBytesSaved += (originalByteSize - compressedByteSize);
+        return {
+            data,
+            scale,
+            offset,
+            tier,
+            originalLength: vector.length,
+            bitDepth: effectiveBitsPerElement,
+            originalByteSize,
+            compressedByteSize,
+            actualByteSize,
+            theoreticalByteSize,
+        };
+    }
+    /**
+     * Decompress a compressed vector back to Float32Array.
+     *
+     * The output is an approximation of the original due to quantization loss.
+     * Consumers receive a standard Float32Array transparently.
+     *
+     * @param compressed - The compressed vector to restore
+     * @returns Reconstructed Float32Array
+     */
+    decompress(compressed) {
+        if (nativeAvailable && nativeModule) {
+            return nativeModule.decompress(compressed.data, compressed.scale, compressed.offset, compressed.originalLength);
+        }
+        return dequantize(compressed.data, compressed.scale, compressed.offset, compressed.tier);
+    }
+    /**
+     * Get current compression statistics for monitoring.
+     */
+    getCompressionStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset compression statistics. Useful for testing or periodic reporting.
+     */
+    resetStats() {
+        this.stats = {
+            totalCompressed: 0,
+            byTier: { hot: 0, warm: 0, cold: 0 },
+            avgCompressionRatio: { hot: 0, warm: 0, cold: 0 },
+            totalBytesSaved: 0,
+            totalOriginalBytes: 0,
+            totalCompressedBytes: 0,
+            usingNative: this.stats.usingNative,
+            usesNativeBitPacking: this.stats.usesNativeBitPacking,
+        };
+        this.ratioSums = { hot: 0, warm: 0, cold: 0 };
+    }
+}
+// ============================================================================
+// Cosine Similarity Utility (for quality validation)
+// ============================================================================
+/**
+ * Compute cosine similarity between two vectors.
+ * Returns a value in [-1, 1] where 1 means identical direction.
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    return denominator === 0 ? 0 : dotProduct / denominator;
+}
+// ============================================================================
+// Singleton & Factory
+// ============================================================================
+let sharedInstance = null;
+/**
+ * Get or create the shared TemporalCompressionService singleton.
+ */
+export async function getTemporalCompressionService() {
+    if (!sharedInstance) {
+        sharedInstance = new TemporalCompressionService();
+        await sharedInstance.initialize();
+    }
+    return sharedInstance;
+}
+/**
+ * Create a new TemporalCompressionService (non-singleton, for testing).
+ */
+export function createTemporalCompressionService() {
+    return new TemporalCompressionService();
+}
+/**
+ * Reset the shared singleton. Primarily for test cleanup.
+ */
+export function resetTemporalCompressionService() {
+    sharedInstance = null;
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export { TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS };
+/**
+ * @deprecated Use THEORETICAL_COMPRESSION_RATIOS instead.
+ * Kept for backwards compatibility with existing consumers.
+ */
+export const EXPECTED_COMPRESSION_RATIOS = THEORETICAL_COMPRESSION_RATIOS;
+//# sourceMappingURL=temporal-compression.js.map

package/dist/integrations/ruvector/thompson-sampler.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Thompson Sampling with Beta Priors (Task 2.3, ADR-084)
+ *
+ * Provides a Thompson Sampler for balancing exploration/exploitation in
+ * cross-domain transfer decisions. Each domain pair maintains a Beta(alpha, beta)
+ * distribution that is updated based on transfer outcomes.
+ *
+ * @module integrations/ruvector/thompson-sampler
+ */
+/**
+ * Thompson Sampling with Beta priors for exploration/exploitation balance.
+ *
+ * Each domain pair maintains a Beta(alpha, beta) distribution where:
+ * - alpha = number of successes + 1 (prior)
+ * - beta = number of failures + 1 (prior)
+ *
+ * Sampling from this distribution naturally balances exploration (uncertain
+ * pairs with wide distributions) and exploitation (proven pairs with
+ * narrow distributions centered on high success rates).
+ */
+export declare class ThompsonSampler {
+    /** Beta distribution alpha params: successes + 1 */
+    private alphas;
+    /** Beta distribution beta params: failures + 1 */
+    private betas;
+    /**
+     * Sample from the Beta distribution for a domain pair.
+     *
+     * @param domainPair - Key identifying the source->target pair
+     * @returns Sampled probability of transfer success
+     */
+    sample(domainPair: string): number;
+    /**
+     * Update the Beta distribution after observing a transfer outcome.
+     *
+     * @param domainPair - Key identifying the source->target pair
+     * @param success - Whether the transfer was successful
+     */
+    update(domainPair: string, success: boolean): void;
+    /** Get the mean of the Beta distribution: alpha / (alpha + beta) */
+    getMean(domainPair: string): number;
+    /** Get the total number of observations (excluding priors) */
+    getObservationCount(domainPair: string): number;
+    /** Get the alpha (success count + 1) for a domain pair */
+    getAlpha(domainPair: string): number;
+    /** Get the beta (failure count + 1) for a domain pair */
+    getBeta(domainPair: string): number;
+    /**
+     * Sample from Beta(alpha, beta) via the Gamma-ratio method:
+     * X ~ Gamma(alpha, 1), Y ~ Gamma(beta, 1), return X / (X + Y).
+     */
+    private sampleBeta;
+    /**
+     * Sample from Gamma(shape, 1) using Marsaglia-Tsang for shape >= 1
+     * and rejection method for shape < 1.
+     */
+    private sampleGamma;
+    /** Standard normal sample via Box-Muller transform */
+    private standardNormal;
+}
+//# sourceMappingURL=thompson-sampler.d.ts.map

package/dist/integrations/ruvector/thompson-sampler.js

@@ -0,0 +1,118 @@
+/**
+ * Thompson Sampling with Beta Priors (Task 2.3, ADR-084)
+ *
+ * Provides a Thompson Sampler for balancing exploration/exploitation in
+ * cross-domain transfer decisions. Each domain pair maintains a Beta(alpha, beta)
+ * distribution that is updated based on transfer outcomes.
+ *
+ * @module integrations/ruvector/thompson-sampler
+ */
+// ============================================================================
+// Thompson Sampler
+// ============================================================================
+/**
+ * Thompson Sampling with Beta priors for exploration/exploitation balance.
+ *
+ * Each domain pair maintains a Beta(alpha, beta) distribution where:
+ * - alpha = number of successes + 1 (prior)
+ * - beta = number of failures + 1 (prior)
+ *
+ * Sampling from this distribution naturally balances exploration (uncertain
+ * pairs with wide distributions) and exploitation (proven pairs with
+ * narrow distributions centered on high success rates).
+ */
+export class ThompsonSampler {
+    /** Beta distribution alpha params: successes + 1 */
+    alphas = new Map();
+    /** Beta distribution beta params: failures + 1 */
+    betas = new Map();
+    /**
+     * Sample from the Beta distribution for a domain pair.
+     *
+     * @param domainPair - Key identifying the source->target pair
+     * @returns Sampled probability of transfer success
+     */
+    sample(domainPair) {
+        const alpha = this.alphas.get(domainPair) ?? 1;
+        const beta = this.betas.get(domainPair) ?? 1;
+        return this.sampleBeta(alpha, beta);
+    }
+    /**
+     * Update the Beta distribution after observing a transfer outcome.
+     *
+     * @param domainPair - Key identifying the source->target pair
+     * @param success - Whether the transfer was successful
+     */
+    update(domainPair, success) {
+        if (success) {
+            this.alphas.set(domainPair, (this.alphas.get(domainPair) ?? 1) + 1);
+        }
+        else {
+            this.betas.set(domainPair, (this.betas.get(domainPair) ?? 1) + 1);
+        }
+    }
+    /** Get the mean of the Beta distribution: alpha / (alpha + beta) */
+    getMean(domainPair) {
+        const alpha = this.alphas.get(domainPair) ?? 1;
+        const beta = this.betas.get(domainPair) ?? 1;
+        return alpha / (alpha + beta);
+    }
+    /** Get the total number of observations (excluding priors) */
+    getObservationCount(domainPair) {
+        const alpha = this.alphas.get(domainPair) ?? 1;
+        const beta = this.betas.get(domainPair) ?? 1;
+        return (alpha - 1) + (beta - 1);
+    }
+    /** Get the alpha (success count + 1) for a domain pair */
+    getAlpha(domainPair) {
+        return this.alphas.get(domainPair) ?? 1;
+    }
+    /** Get the beta (failure count + 1) for a domain pair */
+    getBeta(domainPair) {
+        return this.betas.get(domainPair) ?? 1;
+    }
+    /**
+     * Sample from Beta(alpha, beta) via the Gamma-ratio method:
+     * X ~ Gamma(alpha, 1), Y ~ Gamma(beta, 1), return X / (X + Y).
+     */
+    sampleBeta(alpha, beta) {
+        const x = this.sampleGamma(alpha);
+        const y = this.sampleGamma(beta);
+        if (x + y === 0)
+            return 0.5;
+        return x / (x + y);
+    }
+    /**
+     * Sample from Gamma(shape, 1) using Marsaglia-Tsang for shape >= 1
+     * and rejection method for shape < 1.
+     */
+    sampleGamma(shape) {
+        if (shape < 1) {
+            const u = Math.random();
+            return this.sampleGamma(shape + 1) * Math.pow(u, 1 / shape);
+        }
+        const d = shape - 1 / 3;
+        const c = 1 / Math.sqrt(9 * d);
+        for (;;) {
+            let x;
+            let v;
+            do {
+                x = this.standardNormal();
+                v = 1 + c * x;
+            } while (v <= 0);
+            v = v * v * v;
+            const u = Math.random();
+            if (u < 1 - 0.0331 * x * x * x * x)
+                return d * v;
+            if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v)))
+                return d * v;
+        }
+    }
+    /** Standard normal sample via Box-Muller transform */
+    standardNormal() {
+        const u1 = Math.random();
+        const u2 = Math.random();
+        return Math.sqrt(-2 * Math.log(u1 || 1e-10)) * Math.cos(2 * Math.PI * u2);
+    }
+}
+//# sourceMappingURL=thompson-sampler.js.map