bulltrackers-module 1.0.294 → 1.0.296

package/functions/computation-system/executors/PriceBatchExecutor.js

@@ -70,7 +70,6 @@ async function runBatchPriceComputation(config, deps, dateStrings, calcs, target
                                         .collection(config.computationsSubcollection)
                                         .doc(normalizeName(calcManifest.name));
                                     
-                                    // [UPDATE] Add _lastUpdated timestamp
                                     writes.push({ 
                                         ref: docRef, 
                                         data: { 

package/functions/computation-system/executors/StandardExecutor.js

@@ -13,7 +13,7 @@ const { ContextFactory }                                               = require
 const { commitResults }                                                = require('../persistence/ResultCommitter');
 const mathLayer                                                        = require('../layers/index');
 const { performance }                                                  = require('perf_hooks');
-const v8                                                               = require('v8'); // [NEW] For Memory introspection
+const v8                                                               = require('v8'); 
 
 class StandardExecutor {
     static async run(date, calcs, passName, config, deps, rootData, fetchedDeps, previousFetchedDeps, skipStatusWrite = false) {

package/functions/computation-system/features.md

@@ -0,0 +1,395 @@
+# Complete Feature Inventory of BullTrackers Computation System
+
+## Core DAG Engine Features
+
+### 1. **Topological Sorting (Kahn's Algorithm)**
+- **Files**: `ManifestBuilder.js:187-205`
+- **Implementation**: Builds execution passes by tracking in-degrees, queuing zero-dependency nodes
+- **Niche aspect**: Dynamic pass assignment (line 201: `neighborEntry.pass = currentEntry.pass + 1`)
+- **Common in**: Airflow, Prefect, Dagster (all use topological sort)
+
+### 2. **Cycle Detection (Tarjan's SCC Algorithm)**
+- **Files**: `ManifestBuilder.js:98-141`
+- **Implementation**: Strongly Connected Components detection with stack-based traversal
+- **Niche aspect**: Returns human-readable cycle chain (line 137: `cycle.join(' -> ') + ' -> ' + cycle[0]`)
+- **Common in**: Academic graph libraries, rare in production DAG systems (most use simpler DFS)
+
+### 3. **Auto-Discovery Manifest Building**
+- **Files**: `ManifestBuilder.js:143-179`, `ManifestLoader.js:9-42`
+- **Implementation**: Scans directories, instantiates classes, extracts metadata via `getMetadata()` static method
+- **Niche aspect**: Singleton caching with multi-key support (ManifestLoader.js:9)
+- **Common in**: Plugin systems (Airflow providers), less common for computation graphs
+
+## Dependency Management & Optimization
+
+### 4. **Multi-Layered Hash Composition**
+- **Files**: `ManifestBuilder.js:56-95`, `HashManager.js:25-36`
+- **Implementation**: Composite hash from code + epoch + infrastructure + layers + dependencies
+- **Niche aspect**: Infrastructure hash (recursive file tree hashing, HashManager.js:38-79)
+- **Common in**: Build systems (Bazel, Buck), **very rare** in data pipelines
+
+### 5. **Content-Based Dependency Short-Circuiting**
+- **Files**: `WorkflowOrchestrator.js:51-73`
+- **Implementation**: Tracks `resultHash` (output data hash), skips re-run if output unchanged despite code change
+- **Niche aspect**: `dependencyResultHashes` tracking (line 59-67)
+- **Common in**: **Extremely rare** - only seen in specialized incremental computation systems
+
+### 6. **Behavioral Stability Detection (SimHash)**
+- **Files**: `BuildReporter.js:55-89`, `SimRunner.js:12-42`, `Fabricator.js:20-244`
+- **Implementation**: Runs code against deterministic mock data, hashes output to detect "logic changes" vs "cosmetic changes"
+- **Niche aspect**: Seeded random data generation (SeededRandom.js:1-38) for reproducible simulations
+- **Common in**: **Unique** - haven't seen this elsewhere. Conceptually similar to property-based testing but for optimization
+
+### 7. **System Epoch Forcing**
+- **Files**: `system_epoch.js:1-2`, `ManifestBuilder.js:65`
+- **Implementation**: Manual version bump to force global re-computation
+- **Niche aspect**: Single-line file that invalidates all cached results
+- **Common in**: Cache invalidation patterns, but unusual to have a dedicated module
+
+## Execution & Resource Management
+
+### 8. **Streaming Execution with Batch Flushing**
+- **Files**: `StandardExecutor.js:86-158`
+- **Implementation**: Async generators yield data chunks, flush to DB every N users
+- **Niche aspect**: Adaptive flushing based on V8 heap pressure (line 128-145)
+- **Common in**: ETL tools (Spark, Flink use micro-batching), **heap-aware flushing is rare**
+
+### 9. **Memory Heartbeat (Flight Recorder)**
+- **Files**: `computation_worker.js:30-53`
+- **Implementation**: Background timer writes memory stats to Firestore every 2 seconds
+- **Niche aspect**: Uses `.unref()` to prevent blocking process exit (line 50)
+- **Common in**: APM tools (DataDog, New Relic), **embedding in workers is custom**
+
+### 10. **Forensic Crash Analysis & Intelligent Routing**
+- **Files**: `computation_dispatcher.js:31-68`
+- **Implementation**: Reads last memory stats from failed runs, routes to high-mem queue if OOM suspected
+- **Niche aspect**: Parses telemetry to distinguish crash types (line 44-50)
+- **Common in**: Kubernetes autoscaling heuristics, **application-level routing is rare**
+
+### 11. **Circuit Breaker Pattern**
+- **Files**: `StandardExecutor.js:164-173`
+- **Implementation**: Tracks error rate, fails fast if >10% failures after 100 items
+- **Niche aspect**: Runs mid-stream (not just at job start)
+- **Common in**: Microservices (Hystrix, Resilience4j), uncommon in data pipelines
+
+### 12. **Incremental Auto-Sharding**
+- **Files**: `ResultCommitter.js:234-302`
+- **Implementation**: Dynamically splits results into Firestore subcollection shards, tracks shard index across flushes
+- **Niche aspect**: `flushMode: INTERMEDIATE` flag (line 150) to avoid pointer updates mid-stream
+- **Common in**: Database sharding, **dynamic document sharding is custom**
+
+### 13. **GZIP Compression Strategy**
+- **Files**: `ResultCommitter.js:128-157`
+- **Implementation**: Compresses results >50KB, stores as binary blob if <900KB compressed
+- **Niche aspect**: Falls back to sharding if compression fails or exceeds limit
+- **Common in**: Storage layers, integration at application level is custom
+
+## Data Quality & Validation
+
+### 14. **Heuristic Validation (Grey Box)**
+- **Files**: `ResultsValidator.js:8-96`
+- **Implementation**: Statistical analysis (zero%, null%, flatline detection) without knowing schema
+- **Niche aspect**: Weekend mode (line 57-64) - relaxes thresholds on Saturdays/Sundays
+- **Common in**: Data quality tools (Great Expectations, Soda), **weekend-aware thresholds are domain-specific**
+
+### 15. **Contract Discovery & Enforcement**
+- **Files**: `ContractDiscoverer.js:11-120`, `ContractValidator.js:9-64`
+- **Implementation**: Monte Carlo simulation learns behavioral bounds, enforces at runtime
+- **Niche aspect**: Distinguishes "physics limits" (ratios 0-1) from "statistical envelopes" (6-sigma)
+- **Common in**: **Unique** - closest analogue is schema inference (Pandas Profiling) but this is probabilistic + enforced
+
+### 16. **Semantic Gates**
+- **Files**: `ResultCommitter.js:118-127`
+- **Implementation**: Blocks results that violate contracts before writing
+- **Niche aspect**: Differentiated error handling - `SEMANTIC_GATE` errors are non-retryable (line 210-225)
+- **Common in**: Type systems (TypeScript, Mypy), **runtime probabilistic checks are rare**
+
+### 17. **Root Data Availability Tracking**
+- **Files**: `AvailabilityChecker.js:49-87`, `utils.js:11-17`
+- **Implementation**: Centralized index (`system_root_data_index`) tracks what data exists per day
+- **Niche aspect**: Granular user-type checks (speculator vs normal portfolio, line 23-47)
+- **Common in**: Data catalogs (Amundsen, DataHub), **day-level granularity is custom**
+
+### 18. **Impossible State Propagation**
+- **Files**: `WorkflowOrchestrator.js:94-96`, `logger.js:77-93`
+- **Implementation**: Marks calculations as `IMPOSSIBLE` instead of failing them, allows graph to continue
+- **Niche aspect**: Separate "impossible" category in analysis reports (logger.js:86-91)
+- **Common in**: Workflow engines handle failures, **explicit impossible state is rare**
+
+## Orchestration & Coordination
+
+### 19. **Event-Driven Callback Pattern (Zero Polling)**
+- **Files**: `bulltrackers_pipeline.yaml:49-76`, `computation_worker.js:82-104`
+- **Implementation**: Workflow creates callback endpoint, worker POSTs on completion, workflow wakes
+- **Niche aspect**: IAM authentication for callbacks (computation_worker.js:88-91)
+- **Common in**: Cloud Workflows, AWS Step Functions (both support callbacks), **IAM-secured callbacks are best practice but not default**
+
+### 20. **Run State Counter Pattern**
+- **Files**: `computation_dispatcher.js:107-115`, `computation_worker.js:106-123`
+- **Implementation**: Shared Firestore doc tracks `remainingTasks`, workers decrement on completion
+- **Niche aspect**: Transaction-based decrement (computation_worker.js:109-119) ensures atomicity
+- **Common in**: Distributed systems, **Firestore-specific implementation is custom**
+
+### 21. **Audit Ledger (Ledger-DB Pattern)**
+- **Files**: `computation_dispatcher.js:143-163`, `RunRecorder.js:26-99`
+- **Implementation**: Write-once ledger per task (`computation_audit_ledger/{date}/passes/{pass}/tasks/{calc}`)
+- **Niche aspect**: Stores granular timing breakdown (RunRecorder.js:64-70)
+- **Common in**: Event sourcing systems, **granular profiling in ledger is uncommon**
+
+### 22. **Poison Message Handling (DLQ)**
+- **Files**: `computation_worker.js:36-60`
+- **Implementation**: Max retries check via Pub/Sub `deliveryAttempt`, moves to dead letter queue
+- **Niche aspect**: Differentiates deterministic errors (line 194-222) from transient failures
+- **Common in**: Message queues (RabbitMQ, SQS), **logic-aware routing is custom**
+
+### 23. **Catch-Up Logic (Historical Scan)**
+- **Files**: `computation_dispatcher.js:65-81`
+- **Implementation**: Scans full date range (earliest data → target date) instead of just target date
+- **Niche aspect**: Parallel analysis with concurrency limit (line 85)
+- **Common in**: Data pipelines (backfill mode), **integrated into dispatcher is convenient**
+
+## Observability & Debugging
+
+### 24. **Structured Logging System**
+- **Files**: `logger.js:27-118`
+- **Implementation**: Dual output (human-readable + JSON), process tracking, context inheritance
+- **Niche aspect**: `ProcessLogger` class (line 120-148) for scoped logging with auto-stats
+- **Common in**: Production apps (Winston, Bunyan), **process-scoped loggers are nice touch**
+
+### 25. **Date Analysis Reports**
+- **Files**: `logger.js:77-132`
+- **Implementation**: Per-date breakdown of runnable/blocked/impossible/skipped calculations
+- **Niche aspect**: Unicode symbols for visual parsing (line 103)
+- **Common in**: DAG visualization tools, **inline CLI reports are developer-friendly**
+
+### 26. **Build Report Generator**
+- **Files**: `BuildReporter.js:138-248`
+- **Implementation**: Pre-deployment impact analysis showing blast radius of code changes
+- **Niche aspect**: Blast radius calculation (line 62-77) - finds all downstream dependents
+- **Common in**: CI/CD tools (GitHub's "affected projects"), **calculation-level granularity is detailed**
+
+### 27. **System Fingerprinting**
+- **Files**: `BuildReporter.js:28-51`, `HashManager.js:80-111`
+- **Implementation**: SHA-256 hash of entire codebase + manifest, triggers report on change
+- **Niche aspect**: Recursive directory walk with ignore patterns (HashManager.js:44-60)
+- **Common in**: Docker layer caching, **for change detection at deploy-time is creative**
+
+### 28. **Execution Statistics Tracking**
+- **Files**: `StandardExecutor.js:64-71`, `RunRecorder.js:57-70`
+- **Implementation**: Tracks processed/skipped users, setup/stream/processing time breakdowns
+- **Niche aspect**: Profiler-ready structure (RunRecorder.js:64-70) for BigQuery analysis
+- **Common in**: Profilers (cProfile, pyflame), **baked into business logic is pragmatic**
+
+## Data Access Patterns
+
+### 29. **Smart Shard Indexing**
+- **Files**: `data_loader.js:152-213`
+- **Implementation**: Maintains `instrumentId → shardId` index to avoid scanning all shards
+- **Niche aspect**: 24-hour TTL with rebuild logic (line 167-172)
+- **Common in**: Database indexes, **application-level shard routing is custom**
+
+### 30. **Async Generator Streaming**
+- **Files**: `data_loader.js:130-150`
+- **Implementation**: `async function*` yields data chunks, caller consumes with `for await`
+- **Niche aspect**: Supports pre-provided refs (line 132) for dependency injection
+- **Common in**: Node.js streams, **generator-based approach is modern/clean**
+
+### 31. **Cached Data Loader**
+- **Files**: `CachedDataLoader.js:14-73`
+- **Implementation**: Execution-scoped cache for mappings/insights/social data
+- **Niche aspect**: Decompression helper (line 24-32) for transparent GZIP handling
+- **Common in**: Data layers (Apollo Client, React Query), **per-execution scope is appropriate**
+
+### 32. **Deferred Hydration**
+- **Files**: `DependencyFetcher.js:23-66`
+- **Implementation**: Fetches metadata documents, hydrates sharded data on-demand
+- **Niche aspect**: Parallel hydration promises (line 44-47)
+- **Common in**: ORMs (lazy loading), **manual shard hydration is low-level**
+
+## Domain-Specific Intelligence
+
+### 33. **User Classification Engine**
+- **Files**: `profiling.js:24-236`
+- **Implementation**: "Smart Money" scoring with 18+ behavioral signals
+- **Niche aspect**: Multi-factor scoring (portfolio allocation + trade history + execution timing)
+- **Common in**: Fintech risk models, **granularity is impressive**
+
+### 34. **Convex Hull Risk Geometry**
+- **Files**: `profiling.js:338-365`
+- **Implementation**: Monotone Chain algorithm for efficient frontier analysis
+- **Niche aspect**: O(n log n) algorithm choice (profiling.js:345-363)
+- **Common in**: Computational geometry libraries, **integration into user profiling is domain-specific**
+
+### 35. **Kadane's Maximum Drawdown**
+- **Files**: `extractors.js:27-52`
+- **Implementation**: O(n) single-pass algorithm for peak-to-trough decline
+- **Niche aspect**: Returns indices for visualization (line 47)
+- **Common in**: Finance libraries (QuantLib), **clean implementation**
+
+### 36. **Fast Fourier Transform (Cooley-Tukey)**
+- **Files**: `mathematics.js:148-184`
+- **Implementation**: O(n log n) frequency domain analysis with zero-padding
+- **Niche aspect**: Recursive implementation (line 163-183)
+- **Common in**: Signal processing (NumPy, SciPy), **JavaScript implementation is rare**
+
+### 37. **Sliding Window Extrema (Monotonic Queue)**
+- **Files**: `mathematics.js:227-259`
+- **Implementation**: O(n) min/max calculation using deque
+- **Niche aspect**: Dual deques (one for min, one for max, line 236-237)
+- **Common in**: Competitive programming, **production usage is uncommon**
+
+### 38. **Geometric Brownian Motion Simulator**
+- **Files**: `mathematics.js:99-118`
+- **Implementation**: Box-Muller transform for normal random variates, Monte Carlo simulation
+- **Niche aspect**: Returns `Float32Array` for memory efficiency (line 106)
+- **Common in**: Quant finance (Black-Scholes), **typed arrays are performance-conscious**
+
+### 39. **Hit Probability Calculator**
+- **Files**: `mathematics.js:75-97`
+- **Implementation**: Closed-form barrier option pricing formula
+- **Niche aspect**: Custom `normCDF` implementation (line 85-89) avoids external deps
+- **Common in**: Options pricing libraries, **standalone implementation is self-contained**
+
+### 40. **Kernel Density Estimation**
+- **Files**: `mathematics.js:263-288`
+- **Implementation**: Gaussian kernel with weighted samples
+- **Niche aspect**: 3-bandwidth cutoff for performance (line 276)
+- **Common in**: Stats packages (SciPy, R), **production KDE is uncommon**
+
+## Schema & Type Management
+
+### 41. **Schema Capture System**
+- **Files**: `schema_capture.js:28-68`
+- **Implementation**: Batch stores class-defined schemas to Firestore
+- **Niche aspect**: Pre-commit validation (line 32-34) prevents batch failures
+- **Common in**: Schema registries (Confluent), **lightweight alternative**
+
+### 42. **Production Schema Validators**
+- **Files**: `validators.js:14-137`
+- **Implementation**: Structural validation matching schema.md definitions
+- **Niche aspect**: Separate validators per data type (portfolio/history/social/insights/prices)
+- **Common in**: Data quality frameworks, **schema.md alignment is discipline**
+
+### 43. **Legacy Mapping System**
+- **Files**: `HashManager.js:8-23`, `ContextFactory.js:12-17`
+- **Implementation**: Alias mapping for backward compatibility (e.g., `extract` → `DataExtractor`)
+- **Niche aspect**: Dual injection into context (line 14-16)
+- **Common in**: API versioning, **maintaining during refactor is good practice**
+
+## Infrastructure & Operations
+
+### 44. **Self-Healing Sharding Strategy**
+- **Files**: `ResultCommitter.js:234-302`
+- **Implementation**: Progressively stricter sharding on failure (900KB → 450KB → 200KB → 100KB)
+- **Niche aspect**: Strategy array iteration (line 241-246)
+- **Common in**: Resilience patterns, **adaptive sharding is creative**
+
+### 45. **Initial Write Cleanup Logic**
+- **Files**: `ResultCommitter.js:111-127`, `StandardExecutor.js:122-124`
+- **Implementation**: `isInitialWrite` flag triggers shard deletion before first write
+- **Niche aspect**: Transition detection (line 115-121) from sharded → compressed
+- **Common in**: Migration scripts, **baked into write path is convenient**
+
+### 46. **Firestore Byte Calculator**
+- **Files**: `ResultCommitter.js:319-324`
+- **Implementation**: Estimates document size for batch limits
+- **Niche aspect**: Handles `DocumentReference` paths (line 322)
+- **Common in**: Firestore SDKs (internal), **custom implementation for control**
+
+### 47. **Retry with Exponential Backoff**
+- **Files**: `utils.js:65-79`
+- **Implementation**: Async retry wrapper with configurable attempts and backoff
+- **Niche aspect**: 1s → 2s → 4s progression (line 75)
+- **Common in**: HTTP clients (axios, got), **standalone utility is reusable**
+
+### 48. **Batch Commit Chunker**
+- **Files**: `utils.js:86-128`
+- **Implementation**: Splits writes into Firestore 500-op/10MB batches
+- **Niche aspect**: Supports DELETE operations (line 103-108)
+- **Common in**: ORMs (SQLAlchemy bulk), **DELETE support is complete**
+
+### 49. **Date Range Generator**
+- **Files**: `utils.js:131-139`
+- **Implementation**: UTC-aware date string generation
+- **Niche aspect**: Forces UTC via `Date.UTC()` constructor (line 133-134)
+- **Common in**: Date libraries (date-fns, Luxon), **UTC enforcement is critical for finance**
+
+### 50. **Earliest Date Discovery**
+- **Files**: `utils.js:158-207`
+- **Implementation**: Scans multiple collections to find first available data
+- **Niche aspect**: Handles both flat and sharded collections (line 142-157, 160-174)
+- **Common in**: Data discovery tools, **multi-source aggregation is thorough**
+
+## Advanced Patterns
+
+### 51. **Tarjan's Stack Management**
+- **Files**: `ManifestBuilder.js:98-141`
+- **Implementation**: Manual stack tracking for SCC detection
+- **Niche aspect**: `onStack` Set for O(1) membership checks (line 106)
+- **Common in**: Graph algorithm implementations, **production usage is advanced**
+
+### 52. **Dependency-Injection Context Factory**
+- **Files**: `ContextFactory.js:17-61`
+- **Implementation**: Separate builders for per-user vs meta contexts
+- **Niche aspect**: Math layer injection with legacy aliases (line 12-17)
+- **Common in**: DI frameworks (Spring, Guice), **manual factory is lightweight**
+
+### 53. **Price Batch Executor**
+- **Files**: `PriceBatchExecutor.js:12-104`
+- **Implementation**: Specialized executor for price-only calculations (optimization pass)
+- **Niche aspect**: Outer concurrency (2) + shard batching (20) + write batching (50) nested limits
+- **Common in**: MapReduce systems, **three-level batching is complex**
+
+### 54. **Deterministic Mock Data Fabrication**
+- **Files**: `Fabricator.js:20-244`, `SeededRandom.js:8-38`
+- **Implementation**: LCG PRNG seeded by calculation name for reproducible fakes
+- **Niche aspect**: Iteration-based seed rotation (Fabricator.js:29)
+- **Common in**: Property-based testing (Hypothesis, QuickCheck), **for optimization is novel**
+
+### 55. **Schema-Driven Fake Generation**
+- **Files**: `Fabricator.js:48-71`
+- **Implementation**: Recursively generates data matching JSON schema
+- **Niche aspect**: Volume scaling flag (line 49) for aggregate vs per-item data
+- **Common in**: Schema-based generators (JSF, json-schema-faker), **custom to domain**
+
+### 56. **Migration Cleanup Hook**
+- **Files**: `ResultCommitter.js:81-83`, `ResultCommitter.js:305-317`
+- **Implementation**: Deletes old category data when calculation moves
+- **Niche aspect**: `previousCategory` tracking in manifest (WorkflowOrchestrator.js:50-54)
+- **Common in**: Schema migration tools (Alembic, Flyway), **inline cleanup is pragmatic**
+
+### 57. **Non-Retryable Error Classification**
+- **Files**: `ResultCommitter.js:18-21`, `computation_worker.js:194-225`
+- **Implementation**: Distinguishes deterministic failures from transient errors
+- **Niche aspect**: `error.stage` property for categorization (computation_worker.js:205-209)
+- **Common in**: Error handling libraries (Sentry), **semantic error types are good practice**
+
+### 58. **Reverse Adjacency Graph**
+- **Files**: `BuildReporter.js:62-77`
+- **Implementation**: Maintains child → parent edges for impact analysis
+- **Niche aspect**: Used for blast radius calculation (line 66-74)
+- **Common in**: Dependency analyzers (npm-why), **runtime maintenance is useful**
+
+### 59. **Multi-Key Manifest Cache**
+- **Files**: `ManifestLoader.js:9-14`
+- **Implementation**: Cache key is JSON-stringified sorted product lines
+- **Niche aspect**: Handles `['ALL']` vs `['crypto', 'stocks']` as different keys
+- **Common in**: Memoization libraries (lodash.memoize), **cache key design is thoughtful**
+
+### 60. **Workflow Variable Restoration**
+- **Files**: `bulltrackers_pipeline.yaml:11-17`
+- **Implementation**: Comment notes a bug fix restoring `passes` and `max_retries` variables
+- **Niche aspect**: T-1 date logic (line 13-15) for "process yesterday" pattern
+- **Common in**: Production YAML configs, **inline documentation is helpful**
+
+---
+
+## Summary Statistics
+
+- **Total Features Identified**: 60
+- **Unique/Rare Features**: ~15 (SimHash, content-based short-circuit, forensic routing, contract discovery, weekend validation, behavioral stability, heap-aware flushing, monotonic queue extrema, FFT, KDE, smart shard indexing, recursive infra hash, semantic gates, impossible propagation, blast radius)
+- **Advanced CS Algorithms**: 8 (Kahn's, Tarjan's, Convex Hull, Kadane's, FFT, Box-Muller, Monotonic Queue, LCG)
+- **Common Patterns (Elevated)**: ~25 (executed exceptionally well or with domain-specific twist)
+- **Standard Infrastructure**: ~22 (logging, retries, batching, streaming, caching, validation, etc.)
+
+**Verdict**: About 25% truly novel, 40% common patterns elevated to production-grade, 35% standard infrastructure executed well.

package/functions/computation-system/helpers/computation_dispatcher.js

@@ -29,6 +29,7 @@ async function checkCrashForensics(db, date, pass, computationName) {
         const ledgerPath = `computation_audit_ledger/${date}/passes/${pass}/tasks/${computationName}`;
         const doc = await db.doc(ledgerPath).get();
 
+        // Default to standard
         if (!doc.exists) return 'standard';
 
         const data = doc.data();
@@ -64,8 +65,8 @@ async function checkCrashForensics(db, date, pass, computationName) {
  */
 async function dispatchComputationPass(config, dependencies, computationManifest, reqBody = {}) {
     const { logger, db } = dependencies;
-    const pubsubUtils = new PubSubUtils(dependencies);
-    const passToRun   = String(config.COMPUTATION_PASS_TO_RUN);
+    const pubsubUtils    = new PubSubUtils(dependencies);
+    const passToRun      = String(config.COMPUTATION_PASS_TO_RUN);
     
     // Extract Date and Callback from request body (pushed by Workflow)
     // NOTE: 'dateStr' acts as the "Target Date" (Ceiling), usually T-1.
@@ -75,9 +76,7 @@ async function dispatchComputationPass(config, dependencies, computationManifest
     if (!passToRun) { return logger.log('ERROR', '[Dispatcher] No pass defined (COMPUTATION_PASS_TO_RUN). Aborting.'); }
     if (!dateStr)   { return logger.log('ERROR', '[Dispatcher] No date defined. Aborting.'); }
 
-    const currentManifestHash = generateCodeHash(
-        computationManifest.map(c => c.hash).sort().join('|')
-    );
+    const currentManifestHash = generateCodeHash( computationManifest.map(c => c.hash).sort().join('|') );
 
     const passes          = groupByPass(computationManifest);
     const calcsInThisPass = passes[passToRun] || [];
@@ -129,9 +128,9 @@ async function dispatchComputationPass(config, dependencies, computationManifest
                 }
             }
 
-            const results = await Promise.all(fetchPromises);
-            const dailyStatus = results[0];
-            const availability = results[1];
+            const results         = await Promise.all(fetchPromises);
+            const dailyStatus     = results[0];
+            const availability    = results[1];
             const prevDailyStatus = (prevDateStr && results[2]) ? results[2] : (prevDateStr ? {} : null);
 
             const rootDataStatus = availability ? availability.status : {
@@ -220,9 +219,9 @@ async function dispatchComputationPass(config, dependencies, computationManifest
         
         // 3. Create Audit Ledger Entries
         const finalDispatched = [];
-        const txnLimit = pLimit(20);
+        const txnLimit        = pLimit(20);
         
-        const txnPromises = tasksToDispatch.map(task => txnLimit(async () => {
+        const txnPromises   = tasksToDispatch.map(task => txnLimit(async () => {
             const ledgerRef = db.collection(`computation_audit_ledger/${task.date}/passes/${task.pass}/tasks`).doc(task.computation);
             
             try {

package/functions/computation-system/layers/extractors.js

@@ -120,8 +120,8 @@ class DataExtractor {
         return "Buy"; 
     }
 
-    static getLeverage(position) { return position ? (position.Leverage || 1) : 1; }
-    static getOpenRate(position) { return position ? (position.OpenRate || 0) : 0; }
+    static getLeverage(position)    { return position ? (position.Leverage    || 1) : 1; }
+    static getOpenRate(position)    { return position ? (position.OpenRate    || 0) : 0; }
     static getCurrentRate(position) { return position ? (position.CurrentRate || 0) : 0; }
     static getStopLossRate(position) {
         const rate = position ? (position.StopLossRate || 0) : 0; 
@@ -207,7 +207,7 @@ class HistoryExtractor {
                     });
                 }
                 const asset = assetsMap.get(instId);
-                const open = new Date(t.OpenDateTime);
+                const open  = new Date(t.OpenDateTime);
                 const close = new Date(t.CloseDateTime);
                 const durationMins = (close - open) / 60000;
                 if (durationMins > 0) {
@@ -287,25 +287,25 @@ class InsightsExtractor {
         return insights.find(i => i.instrumentId === instrumentId) || null;
     }
 
-    static getTotalOwners(insight) { return insight ? (insight.total || 0) : 0; }
-    static getLongPercent(insight) { return insight ? (insight.buy || 0) : 0; }
-    static getShortPercent(insight) { return insight ? (insight.sell || 0) : 0; }
+    static getTotalOwners(insight)   { return insight ? (insight.total  || 0) : 0; }
+    static getLongPercent(insight)   { return insight ? (insight.buy    || 0) : 0; }
+    static getShortPercent(insight)  { return insight ? (insight.sell   || 0) : 0; }
     static getGrowthPercent(insight) { return insight ? (insight.growth || 0) : 0; }
 
     static getLongCount(insight) {
-        const total = this.getTotalOwners(insight);
+        const total  = this.getTotalOwners(insight);
         const buyPct = this.getLongPercent(insight);
         return Math.floor(total * (buyPct / 100));
     }
 
     static getShortCount(insight) {
-        const total = this.getTotalOwners(insight);
+        const total   = this.getTotalOwners(insight);
         const sellPct = this.getShortPercent(insight);
         return Math.floor(total * (sellPct / 100));
     }
 
     static getNetOwnershipChange(insight) {
-        const total = this.getTotalOwners(insight);
+        const total  = this.getTotalOwners(insight);
         const growth = this.getGrowthPercent(insight);
         if (total === 0) return 0;
         const prevTotal = total / (1 + (growth / 100)); 

package/functions/computation-system/persistence/RunRecorder.js

@@ -60,12 +60,12 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
 
         // [IDEA 2] Enhanced Execution Stats
         executionStats: {
-            processedUsers: rawExecStats.processedUsers || 0,
-            skippedUsers:   rawExecStats.skippedUsers || 0,
+            processedUsers: rawExecStats.processedUsers     || 0,
+            skippedUsers:   rawExecStats.skippedUsers       || 0,
             // Explicitly break out timings for BigQuery/Analysis
             timings: {
-                setupMs:      Math.round(timings.setup || 0),
-                streamMs:     Math.round(timings.stream || 0),
+                setupMs:      Math.round(timings.setup      || 0),
+                streamMs:     Math.round(timings.stream     || 0),
                 processingMs: Math.round(timings.processing || 0)
             }
         },
@@ -73,8 +73,8 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
         outputStats: {
             sizeMB: sizeMB,
             isSharded: !!detailedMetrics.storage?.isSharded,
-            shardCount: detailedMetrics.storage?.shardCount || 1,
-            keysWritten: detailedMetrics.storage?.keys || 0 
+            shardCount:  detailedMetrics.storage?.shardCount || 1,
+            keysWritten: detailedMetrics.storage?.keys       || 0 
         },
 
         anomalies: anomalies,
@@ -84,9 +84,9 @@ async function recordRunAttempt(db, context, status, error = null, detailedMetri
     if (error) {
         runEntry.error = {
             message: error.message || 'Unknown Error',
-            stage: error.stage || 'UNKNOWN',
-            stack: error.stack ? error.stack.substring(0, 1000) : null,
-            code: error.code || null
+            stage:   error.stage   || 'UNKNOWN',
+            stack:   error.stack    ? error.stack.substring(0, 1000) : null,
+            code:    error.code    || null
         };
     }
 

package/functions/generic-api/admin-api/index.js

@@ -0,0 +1,385 @@
+/**
+ * @fileoverview Admin API Router
+ * Sub-module for system observability, debugging, and visualization.
+ * Mounted at /admin within the Generic API.
+ */
+
+const express = require('express');
+const pLimit = require('p-limit');
+const { getManifest } = require('../../computation-system/topology/ManifestLoader');
+const { normalizeName } = require('../../computation-system/utils/utils');
+
+/**
+ * Factory to create the Admin Router.
+ * @param {object} config - System configuration.
+ * @param {object} dependencies - { db, logger, ... }
+ * @param {object} unifiedCalculations - The injected calculations package.
+ */
+const createAdminRouter = (config, dependencies, unifiedCalculations) => {
+    const router = express.Router();
+    const { db, logger } = dependencies;
+
+    // Helper to get fresh manifest
+    const getFullManifest = () => getManifest([], unifiedCalculations, dependencies);
+
+    // --- 1. TOPOLOGY VISUALIZER ---
+    router.get('/topology', async (req, res) => {
+        try {
+            const manifest = getFullManifest();
+            const nodes = [];
+            const edges = [];
+
+            manifest.forEach(calc => {
+                nodes.push({
+                    id: calc.name,
+                    data: { 
+                        label: calc.name,
+                        layer: calc.category,
+                        pass: calc.pass,
+                        isHistorical: calc.isHistorical,
+                        type: calc.type
+                    },
+                    position: { x: 0, y: 0 }
+                });
+
+                if (calc.dependencies) {
+                    calc.dependencies.forEach(dep => {
+                        edges.push({
+                            id: `e-${dep}-${calc.name}`,
+                            source: normalizeName(dep),
+                            target: calc.name,
+                            type: 'smoothstep'
+                        });
+                    });
+                }
+                
+                if (calc.rootDataDependencies) {
+                    calc.rootDataDependencies.forEach(root => {
+                        const rootId = `ROOT_${root.toUpperCase()}`;
+                        if (!nodes.find(n => n.id === rootId)) {
+                            nodes.push({
+                                id: rootId,
+                                type: 'input',
+                                data: { label: `${root.toUpperCase()} DB` },
+                                position: { x: 0, y: 0 },
+                                style: { background: '#f0f0f0', border: '1px solid #777' }
+                            });
+                        }
+                        edges.push({
+                            id: `e-root-${root}-${calc.name}`,
+                            source: rootId,
+                            target: calc.name,
+                            animated: true,
+                            style: { stroke: '#ff0072' }
+                        });
+                    });
+                }
+            });
+
+            res.json({ summary: { totalNodes: nodes.length, totalEdges: edges.length }, nodes, edges });
+        } catch (e) {
+            logger.log('ERROR', '[AdminAPI] Topology build failed', e);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 2. STATUS MATRIX (Calendar / State UI) ---
+    // Returns status of ALL computations across a date range.
+    // ENHANCED: Cross-references Manifest to detect "PENDING" (Not run yet) vs "MISSING".
+    router.get('/matrix', async (req, res) => {
+        const { start, end } = req.query;
+        if (!start || !end) return res.status(400).json({ error: "Start and End dates required." });
+
+        try {
+            const startDate = new Date(String(start));
+            const endDate = new Date(String(end));
+            const dates = [];
+            for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+                dates.push(d.toISOString().slice(0, 10));
+            }
+
+            const manifest = getFullManifest();
+            const allCalcNames = new Set(manifest.map(c => c.name));
+
+            const limit = pLimit(20);
+            const matrix = {};
+
+            await Promise.all(dates.map(date => limit(async () => {
+                // Fetch Status and Root Data Availability
+                const [statusSnap, rootSnap] = await Promise.all([
+                    db.collection('computation_status').doc(date).get(),
+                    db.collection('system_root_data_index').doc(date).get()
+                ]);
+
+                const statusData = statusSnap.exists ? statusSnap.data() : {};
+                const rootData = rootSnap.exists ? rootSnap.data() : { status: { hasPortfolio: false } };
+
+                const dateStatus = {};
+
+                // Check every calculation in the Manifest
+                allCalcNames.forEach(calcName => {
+                    const entry = statusData[calcName];
+                    
+                    if (!entry) {
+                        // If root data exists but calc is missing -> PENDING
+                        // If no root data -> WAITING_DATA
+                        dateStatus[calcName] = rootData.status?.hasPortfolio ? 'PENDING' : 'WAITING_DATA';
+                    } else if (typeof entry === 'object') {
+                        if (entry.hash && typeof entry.hash === 'string' && entry.hash.startsWith('IMPOSSIBLE')) {
+                            dateStatus[calcName] = 'IMPOSSIBLE';
+                        } else if (entry.hash === false) {
+                            dateStatus[calcName] = 'BLOCKED';
+                        } else {
+                            dateStatus[calcName] = 'COMPLETED';
+                        }
+                    } else if (entry === 'IMPOSSIBLE') {
+                        dateStatus[calcName] = 'IMPOSSIBLE';
+                    } else {
+                        dateStatus[calcName] = 'COMPLETED';
+                    }
+                });
+
+                matrix[date] = {
+                    dataAvailable: rootData.status || {},
+                    calculations: dateStatus
+                };
+            })));
+
+            res.json(matrix);
+        } catch (e) {
+            logger.log('ERROR', '[AdminAPI] Matrix fetch failed', e);
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 3. PIPELINE STATE (Progress Bar) ---
+    // Shows realtime status of the 5-pass system for a specific date
+    router.get('/pipeline/state', async (req, res) => {
+        const { date } = req.query;
+        if (!date) return res.status(400).json({ error: "Date required" });
+
+        try {
+            const passes = ['1', '2', '3', '4', '5'];
+            const state = await Promise.all(passes.map(async (pass) => {
+                // We use the Audit Ledger which is the source of truth for execution state
+                const tasksSnap = await db.collection(`computation_audit_ledger/${date}/passes/${pass}/tasks`).get();
+                
+                const stats = {
+                    pending: 0,
+                    inProgress: 0,
+                    completed: 0,
+                    failed: 0,
+                    totalMemoryMB: 0,
+                    avgDurationMs: 0
+                };
+                
+                const durations = [];
+                
+                tasksSnap.forEach(doc => {
+                    const data = doc.data();
+                    const s = (data.status || 'UNKNOWN').toLowerCase();
+                    if (stats[s] !== undefined) stats[s]++;
+                    else stats[s] = 1;
+
+                    if (data.telemetry?.lastMemory?.rssMB) {
+                        stats.totalMemoryMB += data.telemetry.lastMemory.rssMB;
+                    }
+                    if (data.completedAt && data.startedAt) {
+                        durations.push(new Date(data.completedAt).getTime() - new Date(data.startedAt).getTime());
+                    }
+                });
+
+                stats.avgDurationMs = durations.length ? 
+                    Math.round(durations.reduce((a, b) => a + b, 0) / durations.length) : 0;
+
+                return { pass, stats, totalTasks: tasksSnap.size };
+            }));
+
+            res.json({ date, passes: state });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 4. DEPENDENCY TRACER (Blast Radius) ---
+    router.get('/trace/:calcName', async (req, res) => {
+        const { calcName } = req.params;
+        const mode = req.query.mode || 'downstream'; // 'upstream' or 'downstream'
+        
+        try {
+            const manifest = getFullManifest();
+            const manifestMap = new Map(manifest.map(c => [c.name, c]));
+            
+            if (!manifestMap.has(calcName)) return res.status(404).json({ error: 'Calculation not found' });
+
+            const trace = { root: calcName, chain: [] };
+
+            if (mode === 'upstream') {
+                // What does X depend on?
+                const visited = new Set();
+                const walk = (name, depth = 0) => {
+                    if (visited.has(name) || depth > 10) return;
+                    visited.add(name);
+                    const calc = manifestMap.get(name);
+                    if (!calc) return;
+                    
+                    trace.chain.push({ 
+                        name, depth, pass: calc.pass, type: calc.type 
+                    });
+                    
+                    calc.dependencies?.forEach(dep => walk(dep, depth + 1));
+                };
+                walk(calcName);
+            } else {
+                // What depends on X? (Downstream / Impact)
+                const reverseGraph = new Map();
+                manifest.forEach(c => {
+                    c.dependencies?.forEach(dep => {
+                        const normDep = normalizeName(dep);
+                        if (!reverseGraph.has(normDep)) reverseGraph.set(normDep, []);
+                        reverseGraph.get(normDep).push(c.name);
+                    });
+                });
+
+                const visited = new Set();
+                const walk = (name, depth = 0) => {
+                    if (visited.has(name) || depth > 10) return;
+                    visited.add(name);
+                    
+                    const calc = manifestMap.get(name);
+                    trace.chain.push({ 
+                        name, depth, pass: calc?.pass 
+                    });
+
+                    reverseGraph.get(name)?.forEach(child => walk(child, depth + 1));
+                };
+                walk(calcName);
+            }
+
+            res.json(trace);
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 5. CONTRACT VIOLATIONS (Quality Gate) ---
+    router.get('/violations', async (req, res) => {
+        const days = parseInt(String(req.query.days)) || 7;
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+
+        try {
+            // Check DLQ for Semantic Failures (Hard Violations)
+            const dlqSnap = await db.collection('computation_dead_letter_queue')
+                .where('finalAttemptAt', '>', cutoff)
+                .where('error.stage', '==', 'SEMANTIC_GATE')
+                .limit(50)
+                .get();
+
+            const violations = [];
+            dlqSnap.forEach(doc => {
+                const data = doc.data();
+                violations.push({
+                    id: doc.id,
+                    computation: data.originalData.computation,
+                    date: data.originalData.date,
+                    reason: data.error.message,
+                    type: 'HARD_VIOLATION',
+                    timestamp: data.finalAttemptAt
+                });
+            });
+
+            // Check Audit Logs for Soft Anomalies (Statistical warnings)
+            const anomalySnap = await db.collectionGroup('history')
+                .where('triggerTime', '>', cutoff.toISOString())
+                .where('anomalies', '!=', []) // Firestore != operator
+                .limit(50)
+                .get();
+
+            anomalySnap.forEach(doc => {
+                const data = doc.data();
+                data.anomalies?.forEach(anomaly => {
+                    violations.push({
+                        id: doc.id,
+                        computation: data.computationName,
+                        date: data.targetDate,
+                        reason: anomaly,
+                        type: 'SOFT_ANOMALY',
+                        timestamp: data.triggerTime
+                    });
+                });
+            });
+
+            // Sort by time desc
+            violations.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+
+            res.json({ count: violations.length, violations });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 6. MEMORY HOTSPOTS (Forensics) ---
+    router.get('/memory/hotspots', async (req, res) => {
+        const thresholdMB = parseInt(String(req.query.threshold)) || 1000; // 1GB default
+        
+        try {
+            // Ledger tasks maintain 'telemetry.lastMemory'
+            // We use collectionGroup to search across all dates/passes
+            const snapshot = await db.collectionGroup('tasks')
+                .where('telemetry.lastMemory.rssMB', '>', thresholdMB)
+                .orderBy('telemetry.lastMemory.rssMB', 'desc')
+                .limit(20)
+                .get();
+
+            const hotspots = [];
+            snapshot.forEach(doc => {
+                const data = doc.data();
+                hotspots.push({
+                    computation: data.computation,
+                    rssMB: data.telemetry.lastMemory.rssMB,
+                    heapMB: data.telemetry.lastMemory.heapUsedMB,
+                    status: data.status,
+                    worker: data.workerId,
+                    date: doc.ref.parent.parent.parent.parent.id // traversing path to get date
+                });
+            });
+            
+            res.json({ count: hotspots.length, hotspots });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // --- 7. FLIGHT RECORDER (Inspection) ---
+    // Existing inspection endpoint kept for drill-down
+    router.get('/inspect/:date/:calcName', async (req, res) => {
+        const { date, calcName } = req.params;
+        try {
+            const passes = ['1', '2', '3', '4', '5'];
+            let executionRecord = null;
+
+            await Promise.all(passes.map(async (pass) => {
+                if (executionRecord) return;
+                const ref = db.doc(`computation_audit_ledger/${date}/passes/${pass}/tasks/${calcName}`);
+                const snap = await ref.get();
+                if (snap.exists) executionRecord = { pass, ...snap.data() };
+            }));
+
+            if (!executionRecord) return res.status(404).json({ status: 'NOT_FOUND' });
+
+            const contractSnap = await db.collection('system_contracts').doc(calcName).get();
+            
+            res.json({
+                execution: executionRecord,
+                contract: contractSnap.exists ? contractSnap.data() : null
+            });
+        } catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    return router;
+};
+
+module.exports = createAdminRouter;

package/functions/generic-api/helpers/api_helpers.js

@@ -1,10 +1,31 @@
 /**
  * @fileoverview API sub-pipes.
- * REFACTORED: Fixed Category Resolution to match ManifestBuilder logic.
- * Implements Status-Based Availability Caching and Smart Date Resolution.
+ * REFACTORED: API V3 - Status-Aware Data Fetching.
+ * UPDATED: Added GZIP Decompression support for fetching compressed results.
  */
 
 const { FieldPath } = require('@google-cloud/firestore');
+const zlib = require('zlib'); // [NEW] Required for decompression
+
+// --- HELPER: DECOMPRESSION ---
+/**
+ * Checks if data is compressed and inflates it if necessary.
+ * @param {object} data - The raw Firestore document data.
+ * @returns {object} The original (decompressed) JSON object.
+ */
+function tryDecompress(data) {
+    if (data && data._compressed === true && data.payload) {
+        try {
+            // Firestore returns Buffers automatically for Blob types
+            return JSON.parse(zlib.gunzipSync(data.payload).toString());
+        } catch (e) {
+            console.error('[API] Decompression failed:', e);
+            // Return empty object or original data on failure to avoid crashing response
+            return {};
+        }
+    }
+    return data;
+}
 
 // --- AVAILABILITY CACHE ---
 class AvailabilityCache {
@@ -147,6 +168,7 @@ const buildCalculationMap = (unifiedCalculations) => {
 
 /**
  * Sub-pipe: pipe.api.helpers.fetchUnifiedData
+ * UPDATED: Uses tryDecompress to handle compressed payloads.
  */
 const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, calcMap) => {
     const { db, logger } = dependencies;
@@ -191,7 +213,8 @@ const fetchUnifiedData = async (config, dependencies, calcKeys, dateStrings, cal
             snapshots.forEach((doc, idx) => {
                 const { date, key } = chunk[idx];
                 if (doc.exists) {
-                    response[date][key] = doc.data();
+                    // [UPDATED] Decompress data if needed
+                    response[date][key] = tryDecompress(doc.data());
                 } else {
                     response[date][key] = null;
                 }
@@ -321,8 +344,11 @@ async function getComputationStructure(computationName, calcMap, config, depende
             .collection(compsSub).doc(computationName);
         const doc = await docRef.get();
         if (!doc.exists) { return { status: 'error', computation: computationName, message: `Summary flag was present for ${latestStoredDate} but doc is missing.` }; }
-        const fullData = doc.data();
+        
+        // [UPDATED] Decompress data for structure inspection
+        const fullData = tryDecompress(doc.data());
         const structureSnippet = createStructureSnippet(fullData);
+        
         return { status: 'success', computation: computationName, category: category, latestStoredDate: latestStoredDate, structureSnippet: structureSnippet, };
     } catch (error) {
         logger.log('ERROR', `API /structure/${computationName} helper failed.`, { errorMessage: error.message });

package/functions/generic-api/index.js

@@ -2,12 +2,16 @@
  * @fileoverview Main entry point for the Generic API module.
  * Export the 'createApiApp' main pipe function.
  * REFACTORED: API V3 - Status-Aware Data Fetching.
+ * UPDATED: Added Admin API Mount.
  */
 
 const express = require('express');
 const cors = require('cors');
 const { buildCalculationMap, createApiHandler, getComputationStructure, createManifestHandler, getDynamicSchema } = require('./helpers/api_helpers.js');
 
+// [NEW] Import Admin Router
+const createAdminRouter = require('./admin-api/index');
+
 /**
  * In-Memory Cache Handler
  * Wrapper that adds TTL cache to GET requests.
@@ -71,8 +75,11 @@ function createApiApp(config, dependencies, unifiedCalculations) {
     app.use(cors({ origin: true }));
     app.use(express.json());
 
+    // --- [NEW] MOUNT ADMIN API ---
+    // This injects the dependencies and the calculations package into the admin router
+    app.use('/admin', createAdminRouter(config, dependencies, unifiedCalculations));
+
     // --- Main API V3 Endpoint ---
-    // createApiHandler now initializes the AvailabilityCache internally
     const originalApiHandler = createApiHandler(config, dependencies, calcMap);
     const cachedApiHandler = createCacheHandler(originalApiHandler, dependencies);
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.294",
+  "version": "1.0.296",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [